feat: refactored the member status mapping

docs/api/openapi.yml

@@ -2101,17 +2101,6 @@ components:
         role:
           type: string
       type: object
-    TypesPostableAcceptInvite:
-      properties:
-        displayName:
-          type: string
-        password:
-          type: string
-        sourceUrl:
-          type: string
-        token:
-          type: string
-      type: object
     TypesPostableBulkInviteRequest:
       properties:
         invites:
@@ -3290,53 +3279,6 @@ paths:
       tags:
       - global
   /api/v1/invite:
-    get:
-      deprecated: false
-      description: This endpoint lists all invites
-      operationId: ListInvite
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    items:
-                      $ref: '#/components/schemas/TypesInvite'
-                    type: array
-                  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
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - ADMIN
-      - tokenizer:
-        - ADMIN
-      summary: List invites
-      tags:
-      - users
     post:
       deprecated: false
       description: This endpoint creates an invite for a user
@@ -3399,151 +3341,6 @@ paths:
       summary: Create invite
       tags:
       - users
-  /api/v1/invite/{id}:
-    delete:
-      deprecated: false
-      description: This endpoint deletes an invite by id
-      operationId: DeleteInvite
-      parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-      responses:
-        "204":
-          description: No Content
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "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: Delete invite
-      tags:
-      - users
-  /api/v1/invite/{token}:
-    get:
-      deprecated: false
-      description: This endpoint gets an invite by token
-      operationId: GetInvite
-      parameters:
-      - in: path
-        name: token
-        required: true
-        schema:
-          type: string
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TypesInvite'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "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
-      summary: Get invite
-      tags:
-      - users
-  /api/v1/invite/accept:
-    post:
-      deprecated: false
-      description: This endpoint accepts an invite by token
-      operationId: AcceptInvite
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/TypesPostableAcceptInvite'
-      responses:
-        "201":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/TypesUser'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: Created
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "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
-      summary: Accept invite
-      tags:
-      - users
   /api/v1/invite/bulk:
     post:
       deprecated: false

ee/licensing/httplicensing/provider.go

@@ -198,10 +198,7 @@ func (provider *provider) Checkout(ctx context.Context, organizationID valuer.UU
 
 	response, err := provider.zeus.GetCheckoutURL(ctx, activeLicense.Key, body)
 	if err != nil {
-		if errors.Ast(err, errors.TypeAlreadyExists) {
-			return nil, errors.WithAdditionalf(err, "checkout has already been completed for this account. Please click 'Refresh Status' to sync your subscription")
-		}
-		return nil, err
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate checkout session")
 	}
 
 	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil
@@ -220,7 +217,7 @@ func (provider *provider) Portal(ctx context.Context, organizationID valuer.UUID
 
 	response, err := provider.zeus.GetPortalURL(ctx, activeLicense.Key, body)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, errors.TypeInternal, errors.CodeInternal, "failed to generate portal session")
 	}
 
 	return &licensetypes.GettableSubscription{RedirectURL: gjson.GetBytes(response, "url").String()}, nil

ee/sqlstore/postgressqlstore/provider.go

@@ -101,7 +101,7 @@ func (provider *provider) WrapNotFoundErrf(err error, code errors.Code, format s
 
 func (provider *provider) WrapAlreadyExistsErrf(err error, code errors.Code, format string, args ...any) error {
 	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) && (pgErr.Code == "23505" || pgErr.Code == "23503") {
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
 		return errors.Wrapf(err, errors.TypeAlreadyExists, code, format, args...)
 	}
 

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

@@ -2511,25 +2511,6 @@ export interface TypesPostableAPIKeyDTO {
 	role?: string;
 }
 
-export interface TypesPostableAcceptInviteDTO {
-	/**
-	 * @type string
-	 */
-	displayName?: string;
-	/**
-	 * @type string
-	 */
-	password?: string;
-	/**
-	 * @type string
-	 */
-	sourceUrl?: string;
-	/**
-	 * @type string
-	 */
-	token?: string;
-}
-
 export interface TypesPostableBulkInviteRequestDTO {
 	/**
 	 * @type array
@@ -3033,17 +3014,6 @@ export type GetGlobalConfig200 = {
 	status: string;
 };
 
-export type ListInvite200 = {
-	/**
-	 * @type array
-	 */
-	data: TypesInviteDTO[];
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type CreateInvite201 = {
 	data: TypesInviteDTO;
 	/**
@@ -3052,28 +3022,6 @@ export type CreateInvite201 = {
 	status: string;
 };
 
-export type DeleteInvitePathParameters = {
-	id: string;
-};
-export type GetInvitePathParameters = {
-	token: string;
-};
-export type GetInvite200 = {
-	data: TypesInviteDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
-export type AcceptInvite201 = {
-	data: TypesUserDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type ListPromotedAndIndexedPaths200 = {
 	/**
 	 * @type array

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

@@ -20,26 +20,20 @@ import { useMutation, useQuery } from 'react-query';
 import type { BodyType, ErrorType } from '../../../generatedAPIInstance';
 import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
 import type {
-	AcceptInvite201,
 	ChangePasswordPathParameters,
 	CreateAPIKey201,
 	CreateInvite201,
-	DeleteInvitePathParameters,
 	DeleteUserPathParameters,
-	GetInvite200,
-	GetInvitePathParameters,
 	GetMyUser200,
 	GetResetPasswordToken200,
 	GetResetPasswordTokenPathParameters,
 	GetUser200,
 	GetUserPathParameters,
 	ListAPIKeys200,
-	ListInvite200,
 	ListUsers200,
 	RenderErrorResponseDTO,
 	RevokeAPIKeyPathParameters,
 	TypesChangePasswordRequestDTO,
-	TypesPostableAcceptInviteDTO,
 	TypesPostableAPIKeyDTO,
 	TypesPostableBulkInviteRequestDTO,
 	TypesPostableForgotPasswordDTO,
@@ -255,84 +249,6 @@ export const invalidateGetResetPasswordToken = async (
 	return queryClient;
 };
 
-/**
- * This endpoint lists all invites
- * @summary List invites
- */
-export const listInvite = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<ListInvite200>({
-		url: `/api/v1/invite`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getListInviteQueryKey = () => {
-	return [`/api/v1/invite`] as const;
-};
-
-export const getListInviteQueryOptions = <
-	TData = Awaited<ReturnType<typeof listInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listInvite>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListInviteQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listInvite>>> = ({
-		signal,
-	}) => listInvite(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listInvite>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListInviteQueryResult = NonNullable<
-	Awaited<ReturnType<typeof listInvite>>
->;
-export type ListInviteQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List invites
- */
-
-export function useListInvite<
-	TData = Awaited<ReturnType<typeof listInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof listInvite>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListInviteQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary List invites
- */
-export const invalidateListInvite = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListInviteQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};
-
 /**
  * This endpoint creates an invite for a user
  * @summary Create invite
@@ -416,257 +332,6 @@ export const useCreateInvite = <
 
 	return useMutation(mutationOptions);
 };
-/**
- * This endpoint deletes an invite by id
- * @summary Delete invite
- */
-export const deleteInvite = ({ id }: DeleteInvitePathParameters) => {
-	return GeneratedAPIInstance<void>({
-		url: `/api/v1/invite/${id}`,
-		method: 'DELETE',
-	});
-};
-
-export const getDeleteInviteMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		TError,
-		{ pathParams: DeleteInvitePathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteInvite>>,
-	TError,
-	{ pathParams: DeleteInvitePathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteInvite'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		{ pathParams: DeleteInvitePathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteInvite(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteInviteMutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteInvite>>
->;
-
-export type DeleteInviteMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete invite
- */
-export const useDeleteInvite = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteInvite>>,
-		TError,
-		{ pathParams: DeleteInvitePathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteInvite>>,
-	TError,
-	{ pathParams: DeleteInvitePathParameters },
-	TContext
-> => {
-	const mutationOptions = getDeleteInviteMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
-/**
- * This endpoint gets an invite by token
- * @summary Get invite
- */
-export const getInvite = (
-	{ token }: GetInvitePathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetInvite200>({
-		url: `/api/v1/invite/${token}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetInviteQueryKey = ({ token }: GetInvitePathParameters) => {
-	return [`/api/v1/invite/${token}`] as const;
-};
-
-export const getGetInviteQueryOptions = <
-	TData = Awaited<ReturnType<typeof getInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ token }: GetInvitePathParameters,
-	options?: {
-		query?: UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetInviteQueryKey({ token });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getInvite>>> = ({
-		signal,
-	}) => getInvite({ token }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!token,
-		...queryOptions,
-	} as UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData> & {
-		queryKey: QueryKey;
-	};
-};
-
-export type GetInviteQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getInvite>>
->;
-export type GetInviteQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get invite
- */
-
-export function useGetInvite<
-	TData = Awaited<ReturnType<typeof getInvite>>,
-	TError = ErrorType<RenderErrorResponseDTO>
->(
-	{ token }: GetInvitePathParameters,
-	options?: {
-		query?: UseQueryOptions<Awaited<ReturnType<typeof getInvite>>, TError, TData>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetInviteQueryOptions({ token }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get invite
- */
-export const invalidateGetInvite = async (
-	queryClient: QueryClient,
-	{ token }: GetInvitePathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetInviteQueryKey({ token }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint accepts an invite by token
- * @summary Accept invite
- */
-export const acceptInvite = (
-	typesPostableAcceptInviteDTO: BodyType<TypesPostableAcceptInviteDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<AcceptInvite201>({
-		url: `/api/v1/invite/accept`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: typesPostableAcceptInviteDTO,
-		signal,
-	});
-};
-
-export const getAcceptInviteMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		TError,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof acceptInvite>>,
-	TError,
-	{ data: BodyType<TypesPostableAcceptInviteDTO> },
-	TContext
-> => {
-	const mutationKey = ['acceptInvite'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-		  'mutationKey' in options.mutation &&
-		  options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return acceptInvite(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type AcceptInviteMutationResult = NonNullable<
-	Awaited<ReturnType<typeof acceptInvite>>
->;
-export type AcceptInviteMutationBody = BodyType<TypesPostableAcceptInviteDTO>;
-export type AcceptInviteMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Accept invite
- */
-export const useAcceptInvite = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof acceptInvite>>,
-		TError,
-		{ data: BodyType<TypesPostableAcceptInviteDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof acceptInvite>>,
-	TError,
-	{ data: BodyType<TypesPostableAcceptInviteDTO> },
-	TContext
-> => {
-	const mutationOptions = getAcceptInviteMutationOptions(options);
-
-	return useMutation(mutationOptions);
-};
 /**
  * This endpoint creates a bulk invite for a user
  * @summary Create bulk invite

frontend/src/api/index.ts

@@ -81,8 +81,7 @@ export const interceptorRejected = async (
 				response.config.url !== '/sessions/email_password' &&
 				!(
 					response.config.url === '/sessions' && response.config.method === 'delete'
-				) &&
-				response.config.url !== '/authz/check'
+				)
 			) {
 				try {
 					const accessToken = getLocalStorageApi(LOCALSTORAGE.AUTH_TOKEN);

frontend/src/api/interceptors.test.ts

@@ -1,152 +0,0 @@
-import axios, { AxiosHeaders, AxiosResponse } from 'axios';
-
-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' },
-		}),
-	),
-}));
-
-jest.mock('AppRoutes/utils', () => ({
-	__esModule: true,
-	default: jest.fn(),
-}));
-
-jest.mock('axios', () => {
-	const actualAxios = jest.requireActual('axios');
-	const mockAxios = jest.fn().mockResolvedValue({ data: 'success' });
-
-	return {
-		...actualAxios,
-		default: Object.assign(mockAxios, {
-			...actualAxios.default,
-			isAxiosError: jest.fn().mockReturnValue(true),
-			create: actualAxios.create,
-		}),
-		__esModule: true,
-	};
-});
-
-describe('interceptorRejected', () => {
-	beforeEach(() => {
-		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 () => {
-		const arrayPayload = [
-			{ relation: 'assignee', object: { resource: { name: 'role' } } },
-			{ relation: 'assignee', object: { resource: { name: 'editor' } } },
-		];
-
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'POST',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: JSON.stringify(arrayPayload),
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'POST',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: JSON.stringify(arrayPayload),
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(Array.isArray(JSON.parse(retryCallConfig.data))).toBe(true);
-		expect(JSON.parse(retryCallConfig.data)).toEqual(arrayPayload);
-	});
-
-	it('should preserve object payload structure when retrying a 401 request', async () => {
-		const objectPayload = { key: 'value', nested: { data: 123 } };
-
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'POST',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: JSON.stringify(objectPayload),
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'POST',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: JSON.stringify(objectPayload),
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(JSON.parse(retryCallConfig.data)).toEqual(objectPayload);
-	});
-
-	it('should handle undefined data gracefully when retrying', async () => {
-		const error = ({
-			response: {
-				status: 401,
-				config: {
-					url: '/some-endpoint',
-					method: 'GET',
-					baseURL: 'http://localhost/',
-					headers: new AxiosHeaders(),
-					data: undefined,
-				},
-			},
-			config: {
-				url: '/some-endpoint',
-				method: 'GET',
-				baseURL: 'http://localhost/',
-				headers: new AxiosHeaders(),
-				data: undefined,
-			},
-		} as unknown) as AxiosResponse;
-
-		try {
-			await interceptorRejected(error);
-		} catch {
-			// Expected to reject after retry
-		}
-
-		const mockAxiosFn = (axios as unknown) as jest.Mock;
-		expect(mockAxiosFn.mock.calls.length).toBe(1);
-		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
-		expect(retryCallConfig.data).toBeUndefined();
-	});
-});

frontend/src/api/v1/invite/get.ts

@@ -1,19 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import { PayloadProps, PendingInvite } from 'types/api/user/getPendingInvites';
-
-const get = async (): Promise<SuccessResponseV2<PendingInvite[]>> => {
-	try {
-		const response = await axios.get<PayloadProps>(`/invite`);
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default get;

frontend/src/api/v1/invite/id/accept.ts

@@ -1,22 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import { PayloadProps, Props } from 'types/api/user/accept';
-import { UserResponse } from 'types/api/user/getUser';
-
-const accept = async (
-	props: Props,
-): Promise<SuccessResponseV2<UserResponse>> => {
-	try {
-		const response = await axios.post<PayloadProps>(`/invite/accept`, props);
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default accept;

frontend/src/api/v1/invite/id/delete.ts

@@ -1,20 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import { Props } from 'types/api/user/deleteInvite';
-
-const del = async (props: Props): Promise<SuccessResponseV2<null>> => {
-	try {
-		const response = await axios.delete(`/invite/${props.id}`);
-
-		return {
-			httpStatusCode: response.status,
-			data: null,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default del;

frontend/src/api/v1/invite/id/get.ts

@@ -1,28 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
-import { AxiosError } from 'axios';
-import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
-import {
-	InviteDetails,
-	PayloadProps,
-	Props,
-} from 'types/api/user/getInviteDetails';
-
-const getInviteDetails = async (
-	props: Props,
-): Promise<SuccessResponseV2<InviteDetails>> => {
-	try {
-		const response = await axios.get<PayloadProps>(
-			`/invite/${props.inviteId}?ref=${window.location.href}`,
-		);
-
-		return {
-			httpStatusCode: response.status,
-			data: response.data.data,
-		};
-	} catch (error) {
-		ErrorResponseHandlerV2(error as AxiosError<ErrorV2Resp>);
-	}
-};
-
-export default getInviteDetails;

frontend/src/assets/UnAuthorized.tsx

@@ -1,14 +1,8 @@
-function UnAuthorized({
-	width = 137,
-	height = 137,
-}: {
-	height?: number;
-	width?: number;
-}): JSX.Element {
+function UnAuthorized(): JSX.Element {
 	return (
 		<svg
-			width={width}
-			height={height}
+			width="137"
+			height="137"
 			viewBox="0 0 137 137"
 			fill="none"
 			xmlns="http://www.w3.org/2000/svg"

frontend/src/components/EditMemberDrawer/EditMemberDrawer.tsx

@@ -7,7 +7,6 @@ import {
 	Check,
 	ChevronDown,
 	Copy,
-	Link,
 	LockKeyhole,
 	RefreshCw,
 	Trash2,
@@ -17,14 +16,11 @@ import { Input } from '@signozhq/input';
 import { toast } from '@signozhq/sonner';
 import { Select } from 'antd';
 import getResetPasswordToken from 'api/v1/factor_password/getResetPasswordToken';
-import sendInvite from 'api/v1/invite/create';
-import cancelInvite from 'api/v1/invite/id/delete';
 import deleteUser from 'api/v1/user/id/delete';
 import update from 'api/v1/user/id/update';
 import { MemberRow } from 'components/MembersTable/MembersTable';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
-import ROUTES from 'constants/routes';
-import { INVITE_PREFIX, MemberStatus } from 'container/MembersSettings/utils';
+import { MemberStatus } from 'container/MembersSettings/utils';
 import { capitalize } from 'lodash-es';
 import { useTimezone } from 'providers/Timezone';
 import { ROLES } from 'types/roles';
@@ -36,7 +32,6 @@ export interface EditMemberDrawerProps {
 	open: boolean;
 	onClose: () => void;
 	onComplete: () => void;
-	onRefetch?: () => void;
 }
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
@@ -45,7 +40,6 @@ function EditMemberDrawer({
 	open,
 	onClose,
 	onComplete,
-	onRefetch,
 }: EditMemberDrawerProps): JSX.Element {
 	const { formatTimezoneAdjustedTimestamp } = useTimezone();
 
@@ -58,11 +52,9 @@ function EditMemberDrawer({
 	const [resetLink, setResetLink] = useState<string | null>(null);
 	const [showResetLinkDialog, setShowResetLinkDialog] = useState(false);
 	const [hasCopiedResetLink, setHasCopiedResetLink] = useState(false);
+	const [linkType, setLinkType] = useState<'invite' | 'reset' | null>(null);
 
 	const isInvited = member?.status === MemberStatus.Invited;
-	// Invited member IDs are prefixed with 'invite-'; strip it to get the real invite ID
-	const inviteId =
-		isInvited && member ? member.id.slice(INVITE_PREFIX.length) : null;
 
 	useEffect(() => {
 		if (member) {
@@ -73,7 +65,7 @@ function EditMemberDrawer({
 
 	const isDirty =
 		member !== null &&
-		(displayName !== member.name || selectedRole !== member.role);
+		(displayName !== (member.name ?? '') || selectedRole !== member.role);
 
 	const formatTimestamp = useCallback(
 		(ts: string | null | undefined): string => {
@@ -89,80 +81,22 @@ function EditMemberDrawer({
 		[formatTimezoneAdjustedTimestamp],
 	);
 
-	const saveInvitedMember = useCallback(async (): Promise<void> => {
-		if (!member || !inviteId) {
-			return;
-		}
-		await cancelInvite({ id: inviteId });
-		try {
-			await sendInvite({
-				email: member.email,
-				name: displayName,
-				role: selectedRole,
-				frontendBaseUrl: window.location.origin,
-			});
-			toast.success('Invite updated successfully', { richColors: true });
-			onComplete();
-			onClose();
-		} catch {
-			onRefetch?.();
-			onClose();
-			toast.error(
-				'Failed to send the updated invite. Please re-invite this member.',
-				{ richColors: true },
-			);
-		}
-	}, [
-		member,
-		inviteId,
-		displayName,
-		selectedRole,
-		onComplete,
-		onClose,
-		onRefetch,
-	]);
-
-	const saveActiveMember = useCallback(async (): Promise<void> => {
-		if (!member) {
-			return;
-		}
-		await update({
-			userId: member.id,
-			displayName,
-			role: selectedRole,
-		});
-		toast.success('Member details updated successfully', { richColors: true });
-		onComplete();
-		onClose();
-	}, [member, displayName, selectedRole, onComplete, onClose]);
-
 	const handleSave = useCallback(async (): Promise<void> => {
 		if (!member || !isDirty) {
 			return;
 		}
 		setIsSaving(true);
 		try {
-			if (isInvited && inviteId) {
-				await saveInvitedMember();
-			} else {
-				await saveActiveMember();
-			}
+			await update({ userId: member.id, displayName, role: selectedRole });
+			toast.success('Member details updated successfully', { richColors: true });
+			onComplete();
+			onClose();
 		} catch {
-			toast.error(
-				isInvited ? 'Failed to update invite' : 'Failed to update member details',
-				{ richColors: true },
-			);
+			toast.error('Failed to update member details', { richColors: true });
 		} finally {
 			setIsSaving(false);
 		}
-	}, [
-		member,
-		isDirty,
-		isInvited,
-		inviteId,
-		saveInvitedMember,
-		saveActiveMember,
-	]);
+	}, [member, isDirty, displayName, selectedRole, onComplete, onClose]);
 
 	const handleDelete = useCallback(async (): Promise<void> => {
 		if (!member) {
@@ -170,25 +104,23 @@ function EditMemberDrawer({
 		}
 		setIsDeleting(true);
 		try {
-			if (isInvited && inviteId) {
-				await cancelInvite({ id: inviteId });
-				toast.success('Invitation cancelled successfully', { richColors: true });
-			} else {
-				await deleteUser({ userId: member.id });
-				toast.success('Member deleted successfully', { richColors: true });
-			}
+			await deleteUser({ userId: member.id });
+			toast.success(
+				isInvited ? 'Invite revoked successfully' : 'Member deleted successfully',
+				{ richColors: true },
+			);
 			setShowDeleteConfirm(false);
 			onComplete();
 			onClose();
 		} catch {
 			toast.error(
-				isInvited ? 'Failed to cancel invitation' : 'Failed to delete member',
+				isInvited ? 'Failed to revoke invite' : 'Failed to delete member',
 				{ richColors: true },
 			);
 		} finally {
 			setIsDeleting(false);
 		}
-	}, [member, isInvited, inviteId, onComplete, onClose]);
+	}, [member, isInvited, onComplete, onClose]);
 
 	const handleGenerateResetLink = useCallback(async (): Promise<void> => {
 		if (!member) {
@@ -201,6 +133,7 @@ function EditMemberDrawer({
 				const link = `${window.location.origin}/password-reset?token=${response.data.token}`;
 				setResetLink(link);
 				setHasCopiedResetLink(false);
+				setLinkType(isInvited ? 'invite' : 'reset');
 				setShowResetLinkDialog(true);
 				onClose();
 			} else {
@@ -217,7 +150,7 @@ function EditMemberDrawer({
 		} finally {
 			setIsGeneratingLink(false);
 		}
-	}, [member, onClose]);
+	}, [member, isInvited, setLinkType, onClose]);
 
 	const handleCopyResetLink = useCallback(async (): Promise<void> => {
 		if (!resetLink) {
@@ -227,36 +160,18 @@ function EditMemberDrawer({
 			await navigator.clipboard.writeText(resetLink);
 			setHasCopiedResetLink(true);
 			setTimeout(() => setHasCopiedResetLink(false), 2000);
-			toast.success('Reset link copied to clipboard', { richColors: true });
+			toast.success(
+				linkType === 'invite'
+					? 'Invite link copied to clipboard'
+					: 'Reset link copied to clipboard',
+				{ richColors: true },
+			);
 		} catch {
 			toast.error('Failed to copy link', {
 				richColors: true,
 			});
 		}
-	}, [resetLink]);
-
-	const handleCopyInviteLink = useCallback(async (): Promise<void> => {
-		if (!member?.token) {
-			toast.error('Invite link is not available', {
-				richColors: true,
-				position: 'top-right',
-			});
-			return;
-		}
-		const inviteLink = `${window.location.origin}${ROUTES.SIGN_UP}?token=${member.token}`;
-		try {
-			await navigator.clipboard.writeText(inviteLink);
-			toast.success('Invite link copied to clipboard', {
-				richColors: true,
-				position: 'top-right',
-			});
-		} catch {
-			toast.error('Failed to copy invite link', {
-				richColors: true,
-				position: 'top-right',
-			});
-		}
-	}, [member]);
+	}, [resetLink, linkType]);
 
 	const handleClose = useCallback((): void => {
 		setShowDeleteConfirm(false);
@@ -348,30 +263,22 @@ function EditMemberDrawer({
 						onClick={(): void => setShowDeleteConfirm(true)}
 					>
 						<Trash2 size={12} />
-						{isInvited ? 'Cancel Invite' : 'Delete Member'}
+						{isInvited ? 'Revoke Invite' : 'Delete Member'}
 					</Button>
 
 					<div className="edit-member-drawer__footer-divider" />
-
-					{isInvited ? (
-						<Button
-							className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
-							onClick={handleCopyInviteLink}
-							disabled={!member?.token}
-						>
-							<Link size={12} />
-							Copy Invite Link
-						</Button>
-					) : (
-						<Button
-							className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
-							onClick={handleGenerateResetLink}
-							disabled={isGeneratingLink}
-						>
-							<RefreshCw size={12} />
-							{isGeneratingLink ? 'Generating...' : 'Generate Password Reset Link'}
-						</Button>
-					)}
+					<Button
+						className="edit-member-drawer__footer-btn edit-member-drawer__footer-btn--warning"
+						onClick={handleGenerateResetLink}
+						disabled={isGeneratingLink}
+					>
+						<RefreshCw size={12} />
+						{isGeneratingLink
+							? 'Generating...'
+							: isInvited
+							? 'Copy Invite Link'
+							: 'Generate Password Reset Link'}
+					</Button>
 				</div>
 
 				<div className="edit-member-drawer__footer-right">
@@ -394,21 +301,21 @@ function EditMemberDrawer({
 		</div>
 	);
 
-	const deleteDialogTitle = isInvited ? 'Cancel Invitation' : 'Delete Member';
+	const deleteDialogTitle = isInvited ? 'Revoke Invite' : 'Delete Member';
 	const deleteDialogBody = isInvited ? (
 		<>
-			Are you sure you want to cancel the invitation for{' '}
+			Are you sure you want to revoke the invite for{' '}
 			<strong>{member?.email}</strong>? They will no longer be able to join the
 			workspace using this invite.
 		</>
 	) : (
 		<>
 			Are you sure you want to delete{' '}
-			<strong>{member?.name || member?.email}</strong>? This will permanently
-			remove their access to the workspace.
+			<strong>{member?.name || member?.email}</strong>? This will remove their
+			access to the workspace.
 		</>
 	);
-	const deleteConfirmLabel = isInvited ? 'Cancel Invite' : 'Delete Member';
+	const deleteConfirmLabel = isInvited ? 'Revoke Invite' : 'Delete Member';
 
 	return (
 		<>
@@ -434,17 +341,19 @@ function EditMemberDrawer({
 				onOpenChange={(isOpen): void => {
 					if (!isOpen) {
 						setShowResetLinkDialog(false);
+						setLinkType(null);
 					}
 				}}
-				title="Password Reset Link"
+				title={linkType === 'invite' ? 'Invite Link' : 'Password Reset Link'}
 				showCloseButton
 				width="base"
 				className="reset-link-dialog"
 			>
 				<div className="reset-link-dialog__content">
 					<p className="reset-link-dialog__description">
-						This creates a one-time link the team member can use to set a new password
-						for their SigNoz account.
+						{linkType === 'invite'
+							? 'Share this one-time link with the team member to complete their account setup.'
+							: 'This creates a one-time link the team member can use to set a new password for their SigNoz account.'}
 					</p>
 					<div className="reset-link-dialog__link-row">
 						<div className="reset-link-dialog__link-text-wrap">

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

@@ -1,7 +1,6 @@
 import type { ReactNode } from 'react';
 import { toast } from '@signozhq/sonner';
 import getResetPasswordToken from 'api/v1/factor_password/getResetPasswordToken';
-import cancelInvite from 'api/v1/invite/id/delete';
 import deleteUser from 'api/v1/user/id/delete';
 import update from 'api/v1/user/id/update';
 import { MemberStatus } from 'container/MembersSettings/utils';
@@ -48,8 +47,6 @@ jest.mock('@signozhq/dialog', () => ({
 
 jest.mock('api/v1/user/id/update');
 jest.mock('api/v1/user/id/delete');
-jest.mock('api/v1/invite/id/delete');
-jest.mock('api/v1/invite/create');
 jest.mock('api/v1/factor_password/getResetPasswordToken');
 jest.mock('@signozhq/sonner', () => ({
 	toast: {
@@ -60,7 +57,6 @@ jest.mock('@signozhq/sonner', () => ({
 
 const mockUpdate = jest.mocked(update);
 const mockDeleteUser = jest.mocked(deleteUser);
-const mockCancelInvite = jest.mocked(cancelInvite);
 const mockGetResetPasswordToken = jest.mocked(getResetPasswordToken);
 
 const activeMember = {
@@ -74,13 +70,12 @@ const activeMember = {
 };
 
 const invitedMember = {
-	id: 'invite-abc123',
+	id: 'abc123',
 	name: '',
 	email: 'bob@signoz.io',
 	role: 'VIEWER' as ROLES,
 	status: MemberStatus.Invited,
 	joinedOn: '1700000000000',
-	token: 'tok-xyz',
 };
 
 function renderDrawer(
@@ -102,7 +97,6 @@ describe('EditMemberDrawer', () => {
 		jest.clearAllMocks();
 		mockUpdate.mockResolvedValue({ httpStatusCode: 200, data: null });
 		mockDeleteUser.mockResolvedValue({ httpStatusCode: 200, data: null });
-		mockCancelInvite.mockResolvedValue({ httpStatusCode: 200, data: null });
 	});
 
 	it('renders active member details and disables Save when form is not dirty', () => {
@@ -163,36 +157,61 @@ describe('EditMemberDrawer', () => {
 		});
 	});
 
-	it('shows Cancel Invite and Copy Invite Link for invited members; hides Last Modified', () => {
+	it('shows revoke invite and copy invite link for invited members; hides Last Modified', () => {
 		renderDrawer({ member: invitedMember });
 
 		expect(
-			screen.getByRole('button', { name: /cancel invite/i }),
+			screen.getByRole('button', { name: /revoke invite/i }),
 		).toBeInTheDocument();
 		expect(
 			screen.getByRole('button', { name: /copy invite link/i }),
 		).toBeInTheDocument();
+		expect(
+			screen.queryByRole('button', { name: /generate password reset link/i }),
+		).not.toBeInTheDocument();
 		expect(screen.getByText('Invited On')).toBeInTheDocument();
 		expect(screen.queryByText('Last Modified')).not.toBeInTheDocument();
 	});
 
-	it('calls cancelInvite after confirming Cancel Invite for invited members', async () => {
+	it('calls deleteUser after confirming revoke invite for invited members', async () => {
 		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		renderDrawer({ member: invitedMember, onComplete });
 
-		await user.click(screen.getByRole('button', { name: /cancel invite/i }));
+		await user.click(screen.getByRole('button', { name: /revoke invite/i }));
 
 		expect(
-			await screen.findByText(/are you sure you want to cancel the invitation/i),
+			await screen.findByText(/Are you sure you want to revoke the invite/i),
 		).toBeInTheDocument();
 
-		const confirmBtns = screen.getAllByRole('button', { name: /cancel invite/i });
+		const confirmBtns = screen.getAllByRole('button', { name: /revoke invite/i });
 		await user.click(confirmBtns[confirmBtns.length - 1]);
 
 		await waitFor(() => {
-			expect(mockCancelInvite).toHaveBeenCalledWith({ id: 'abc123' });
+			expect(mockDeleteUser).toHaveBeenCalledWith({ userId: 'abc123' });
+			expect(onComplete).toHaveBeenCalled();
+		});
+	});
+
+	it('calls update API when saving changes for an invited member', async () => {
+		const onComplete = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		renderDrawer({ member: { ...invitedMember, name: 'Bob' }, onComplete });
+
+		const nameInput = screen.getByDisplayValue('Bob');
+		await user.clear(nameInput);
+		await user.type(nameInput, 'Bob Updated');
+
+		const saveBtn = screen.getByRole('button', { name: /save member details/i });
+		await waitFor(() => expect(saveBtn).not.toBeDisabled());
+		await user.click(saveBtn);
+
+		await waitFor(() => {
+			expect(mockUpdate).toHaveBeenCalledWith(
+				expect.objectContaining({ userId: 'abc123', displayName: 'Bob Updated' }),
+			);
 			expect(onComplete).toHaveBeenCalled();
 		});
 	});
@@ -260,7 +279,6 @@ describe('EditMemberDrawer', () => {
 
 			fireEvent.click(screen.getByRole('button', { name: /^copy$/i }));
 
-			// Verify success path: writeText called with the correct link
 			await waitFor(() => {
 				expect(mockToast.success).toHaveBeenCalledWith(
 					'Reset link copied to clipboard',

frontend/src/components/MembersTable/MembersTable.tsx

@@ -1,6 +1,6 @@
 import type React from 'react';
 import { Badge } from '@signozhq/badge';
-import { Pagination, Table, Tooltip } from 'antd';
+import { Table, Tooltip } from 'antd';
 import type { ColumnsType, SorterResult } from 'antd/es/table/interface';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import { MemberStatus } from 'container/MembersSettings/utils';
@@ -18,7 +18,6 @@ export interface MemberRow {
 	status: MemberStatus;
 	joinedOn: string | null;
 	updatedAt?: string | null;
-	token?: string | null;
 }
 
 interface MembersTableProps {
@@ -64,11 +63,23 @@ function StatusBadge({ status }: { status: MemberRow['status'] }): JSX.Element {
 			</Badge>
 		);
 	}
-	return (
-		<Badge color="amber" variant="outline">
-			INVITED
-		</Badge>
-	);
+	if (status === MemberStatus.Deleted) {
+		return (
+			<Badge color="cherry" variant="outline">
+				DELETED
+			</Badge>
+		);
+	}
+
+	if (status === MemberStatus.Invited) {
+		return (
+			<Badge color="amber" variant="outline">
+				INVITED
+			</Badge>
+		);
+	}
+
+	return <Badge color="vanilla">⎯</Badge>;
 }
 
 function MembersEmptyState({
@@ -199,14 +210,30 @@ function MembersTable({
 				dataSource={data}
 				rowKey="id"
 				loading={loading}
-				pagination={false}
+				pagination={{
+					current: currentPage,
+					pageSize,
+					total,
+					showTotal: showPaginationTotal,
+					showSizeChanger: false,
+					onChange: onPageChange,
+					className: 'members-table-pagination',
+					hideOnSinglePage: true,
+				}}
 				rowClassName={(_, index): string =>
 					index % 2 === 0 ? 'members-table-row--tinted' : ''
 				}
-				onRow={(record): React.HTMLAttributes<HTMLElement> => ({
-					onClick: (): void => onRowClick?.(record),
-					style: onRowClick ? { cursor: 'pointer' } : undefined,
-				})}
+				onRow={(record): React.HTMLAttributes<HTMLElement> => {
+					const isClickable = onRowClick && record.status !== MemberStatus.Deleted;
+					return {
+						onClick: (): void => {
+							if (isClickable) {
+								onRowClick(record);
+							}
+						},
+						style: isClickable ? { cursor: 'pointer' } : undefined,
+					};
+				}}
 				onChange={(_, __, sorter): void => {
 					if (onSortChange) {
 						onSortChange(
@@ -220,17 +247,6 @@ function MembersTable({
 				}}
 				className="members-table"
 			/>
-			{total > pageSize && (
-				<Pagination
-					current={currentPage}
-					pageSize={pageSize}
-					total={total}
-					showTotal={showPaginationTotal}
-					showSizeChanger={false}
-					onChange={onPageChange}
-					className="members-table-pagination"
-				/>
-			)}
 		</div>
 	);
 }

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

@@ -24,13 +24,12 @@ const mockActiveMembers: MemberRow[] = [
 ];
 
 const mockInvitedMember: MemberRow = {
-	id: 'invite-abc',
+	id: 'inv-abc',
 	name: '',
 	email: 'charlie@signoz.io',
 	role: 'EDITOR' as ROLES,
 	status: MemberStatus.Invited,
 	joinedOn: null,
-	token: 'tok-123',
 };
 
 const defaultProps = {
@@ -93,6 +92,34 @@ describe('MembersTable', () => {
 		);
 	});
 
+	it('renders DELETED badge and does not call onRowClick when a deleted member row is clicked', async () => {
+		const onRowClick = jest.fn();
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		const deletedMember: MemberRow = {
+			id: 'user-del',
+			name: 'Dave Deleted',
+			email: 'dave@signoz.io',
+			role: 'VIEWER' as ROLES,
+			status: MemberStatus.Deleted,
+			joinedOn: null,
+		};
+
+		render(
+			<MembersTable
+				{...defaultProps}
+				data={[...mockActiveMembers, deletedMember]}
+				total={3}
+				onRowClick={onRowClick}
+			/>,
+		);
+
+		expect(screen.getByText('DELETED')).toBeInTheDocument();
+		await user.click(screen.getByText('Dave Deleted'));
+		expect(onRowClick).not.toHaveBeenCalledWith(
+			expect.objectContaining({ id: 'user-del' }),
+		);
+	});
+
 	it('shows "No members found" empty state when no data and no search query', () => {
 		render(<MembersTable {...defaultProps} data={[]} total={0} searchQuery="" />);
 

frontend/src/components/ShiftOverlay/ShiftHoldOverlayController.tsx

@@ -1,13 +1,13 @@
 import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
-import { ROLES } from '../../types/roles';
 import { ShiftOverlay } from './ShiftOverlay';
 import { useShiftHoldOverlay } from './useShiftHoldOverlay';
 
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export function ShiftHoldOverlayController({
 	userRole,
 }: {
-	userRole: ROLES;
+	userRole: UserRole;
 }): JSX.Element | null {
 	const { open: isCmdKOpen } = useCmdK();
 	const noop = (): void => undefined;

frontend/src/components/ShiftOverlay/ShiftOverlay.tsx

@@ -1,18 +1,18 @@
 import { useMemo } from 'react';
 import ReactDOM from 'react-dom';
-import { ROLES } from 'types/roles';
 
 import { formatShortcut } from './formatShortcut';
 
 import './shiftOverlay.scss';
 
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export type CmdAction = {
 	id: string;
 	name: string;
 	shortcut?: string[];
 	keywords?: string;
 	section?: string;
-	roles?: ROLES[];
+	roles?: UserRole[];
 	perform: () => void;
 };
 
@@ -33,7 +33,7 @@ function Shortcut({ label, keyHint }: ShortcutProps): JSX.Element {
 interface ShiftOverlayProps {
 	visible: boolean;
 	actions: CmdAction[];
-	userRole: ROLES;
+	userRole: UserRole;
 }
 
 export function ShiftOverlay({

frontend/src/components/cmdKPalette/cmdKPalette.tsx

@@ -11,7 +11,6 @@ import {
 import logEvent from 'api/common/logEvent';
 import { useThemeMode } from 'hooks/useDarkMode';
 import history from 'lib/history';
-import { ROLES as UserRole } from 'types/roles';
 
 import { createShortcutActions } from '../../constants/shortcutActions';
 import { useCmdK } from '../../providers/cmdKProvider';
@@ -29,6 +28,7 @@ type CmdAction = {
 	perform: () => void;
 };
 
+type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 export function CmdKPalette({
 	userRole,
 }: {

frontend/src/constants/shortcutActions.tsx

@@ -18,7 +18,8 @@ import {
 	TowerControl,
 	Workflow,
 } from 'lucide-react';
-import { ROLES } from 'types/roles';
+
+export type UserRole = 'ADMIN' | 'EDITOR' | 'AUTHOR' | 'VIEWER';
 
 export type CmdAction = {
 	id: string;
@@ -27,7 +28,7 @@ export type CmdAction = {
 	keywords?: string;
 	section?: string;
 	icon?: React.ReactNode;
-	roles?: ROLES[];
+	roles?: UserRole[];
 	perform: () => void;
 };
 

frontend/src/container/MembersSettings/MembersSettings.tsx

@@ -6,7 +6,6 @@ import { Check, ChevronDown, Plus } from '@signozhq/icons';
 import { Input } from '@signozhq/input';
 import type { MenuProps } from 'antd';
 import { Dropdown } from 'antd';
-import getPendingInvites from 'api/v1/invite/get';
 import getAll from 'api/v1/user/get';
 import EditMemberDrawer from 'components/EditMemberDrawer/EditMemberDrawer';
 import InviteMembersModal from 'components/InviteMembersModal/InviteMembersModal';
@@ -14,7 +13,7 @@ import MembersTable, { MemberRow } from 'components/MembersTable/MembersTable';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { useAppContext } from 'providers/App/App';
 
-import { FilterMode, INVITE_PREFIX, MemberStatus } from './utils';
+import { FilterMode, MemberStatus, toMemberStatus } from './utils';
 
 import './MembersSettings.styles.scss';
 
@@ -34,51 +33,24 @@ function MembersSettings(): JSX.Element {
 	const [isInviteModalOpen, setIsInviteModalOpen] = useState(false);
 	const [selectedMember, setSelectedMember] = useState<MemberRow | null>(null);
 
-	const {
-		data: usersData,
-		isLoading: isUsersLoading,
-		refetch: refetchUsers,
-	} = useQuery({
+	const { data: usersData, isLoading, refetch: refetchUsers } = useQuery({
 		queryFn: getAll,
 		queryKey: ['getOrgUser', org?.[0]?.id],
 	});
 
-	const {
-		data: invitesData,
-		isLoading: isInvitesLoading,
-		refetch: refetchInvites,
-	} = useQuery({
-		queryFn: getPendingInvites,
-		queryKey: ['getPendingInvites'],
-	});
-
-	const isLoading = isUsersLoading || isInvitesLoading;
-
-	const allMembers = useMemo((): MemberRow[] => {
-		const activeMembers: MemberRow[] = (usersData?.data ?? []).map((user) => ({
-			id: user.id,
-			name: user.displayName,
-			email: user.email,
-			role: user.role,
-			status: MemberStatus.Active,
-			joinedOn: user.createdAt ? String(user.createdAt) : null,
-			updatedAt: user?.updatedAt ? String(user.updatedAt) : null,
-		}));
-
-		const pendingInvites: MemberRow[] = (invitesData?.data ?? []).map(
-			(invite) => ({
-				id: `${INVITE_PREFIX}${invite.id}`,
-				name: invite.name ?? '',
-				email: invite.email,
-				role: invite.role,
-				status: MemberStatus.Invited,
-				joinedOn: invite.createdAt ? String(invite.createdAt) : null,
-				token: invite.token ?? null,
-			}),
-		);
-
-		return [...activeMembers, ...pendingInvites];
-	}, [usersData, invitesData]);
+	const allMembers = useMemo(
+		(): MemberRow[] =>
+			(usersData?.data ?? []).map((user) => ({
+				id: user.id,
+				name: user.displayName,
+				email: user.email,
+				role: user.role,
+				status: toMemberStatus(user.status ?? ''),
+				joinedOn: user.createdAt ? String(user.createdAt) : null,
+				updatedAt: user.updatedAt ? String(user.updatedAt) : null,
+			})),
+		[usersData],
+	);
 
 	const filteredMembers = useMemo((): MemberRow[] => {
 		let result = allMembers;
@@ -100,11 +72,6 @@ function MembersSettings(): JSX.Element {
 		return result;
 	}, [allMembers, filterMode, searchQuery]);
 
-	const paginatedMembers = useMemo((): MemberRow[] => {
-		const start = (currentPage - 1) * PAGE_SIZE;
-		return filteredMembers.slice(start, start + PAGE_SIZE);
-	}, [filteredMembers, currentPage]);
-
 	// TODO(nuqs): Replace with nuqs once the nuqs setup and integration is done
 	const setPage = useCallback(
 		(page: number): void => {
@@ -124,7 +91,9 @@ function MembersSettings(): JSX.Element {
 		}
 	}, [filteredMembers.length, currentPage, setPage]);
 
-	const pendingCount = invitesData?.data?.length ?? 0;
+	const pendingCount = allMembers.filter(
+		(m) => m.status === MemberStatus.Invited,
+	).length;
 	const totalCount = allMembers.length;
 
 	const filterMenuItems: MenuProps['items'] = [
@@ -163,8 +132,7 @@ function MembersSettings(): JSX.Element {
 
 	const handleInviteComplete = useCallback((): void => {
 		refetchUsers();
-		refetchInvites();
-	}, [refetchUsers, refetchInvites]);
+	}, [refetchUsers]);
 
 	const handleRowClick = useCallback((member: MemberRow): void => {
 		setSelectedMember(member);
@@ -176,9 +144,8 @@ function MembersSettings(): JSX.Element {
 
 	const handleMemberEditComplete = useCallback((): void => {
 		refetchUsers();
-		refetchInvites();
 		setSelectedMember(null);
-	}, [refetchUsers, refetchInvites]);
+	}, [refetchUsers]);
 
 	return (
 		<>
@@ -232,7 +199,7 @@ function MembersSettings(): JSX.Element {
 				</div>
 			</div>
 			<MembersTable
-				data={paginatedMembers}
+				data={filteredMembers}
 				loading={isLoading}
 				total={filteredMembers.length}
 				currentPage={currentPage}
@@ -253,7 +220,6 @@ function MembersSettings(): JSX.Element {
 				open={selectedMember !== null}
 				onClose={handleDrawerClose}
 				onComplete={handleMemberEditComplete}
-				onRefetch={handleInviteComplete}
 			/>
 		</>
 	);

frontend/src/container/MembersSettings/__tests__/MembersSettings.integration.test.tsx

@@ -1,6 +1,5 @@
 import { rest, server } from 'mocks-server/server';
 import { render, screen, userEvent } from 'tests/test-utils';
-import { PendingInvite } from 'types/api/user/getPendingInvites';
 import { UserResponse } from 'types/api/user/getUser';
 
 import MembersSettings from '../MembersSettings';
@@ -13,7 +12,6 @@ jest.mock('@signozhq/sonner', () => ({
 }));
 
 const USERS_ENDPOINT = '*/api/v1/user';
-const INVITES_ENDPOINT = '*/api/v1/invite';
 
 const mockUsers: UserResponse[] = [
 	{
@@ -21,7 +19,8 @@ const mockUsers: UserResponse[] = [
 		displayName: 'Alice Smith',
 		email: 'alice@signoz.io',
 		role: 'ADMIN',
-		createdAt: 1700000000,
+		status: 'active',
+		createdAt: '2024-01-01T00:00:00.000Z',
 		organization: 'TestOrg',
 		orgId: 'org-1',
 	},
@@ -30,20 +29,30 @@ const mockUsers: UserResponse[] = [
 		displayName: 'Bob Jones',
 		email: 'bob@signoz.io',
 		role: 'VIEWER',
-		createdAt: 1700000001,
+		status: 'active',
+		createdAt: '2024-01-02T00:00:00.000Z',
 		organization: 'TestOrg',
 		orgId: 'org-1',
 	},
-];
-
-const mockInvites: PendingInvite[] = [
 	{
 		id: 'inv-1',
+		displayName: '',
 		email: 'charlie@signoz.io',
-		name: 'Charlie',
 		role: 'EDITOR',
-		createdAt: 1700000002,
-		token: 'tok-abc',
+		status: 'pending_invite',
+		createdAt: '2024-01-03T00:00:00.000Z',
+		organization: 'TestOrg',
+		orgId: 'org-1',
+	},
+	{
+		id: 'user-3',
+		displayName: 'Dave Deleted',
+		email: 'dave@signoz.io',
+		role: 'VIEWER',
+		status: 'deleted',
+		createdAt: '2024-01-04T00:00:00.000Z',
+		organization: 'TestOrg',
+		orgId: 'org-1',
 	},
 ];
 
@@ -54,9 +63,6 @@ describe('MembersSettings (integration)', () => {
 			rest.get(USERS_ENDPOINT, (_, res, ctx) =>
 				res(ctx.status(200), ctx.json({ data: mockUsers })),
 			),
-			rest.get(INVITES_ENDPOINT, (_, res, ctx) =>
-				res(ctx.status(200), ctx.json({ data: mockInvites })),
-			),
 		);
 	});
 
@@ -64,14 +70,16 @@ describe('MembersSettings (integration)', () => {
 		server.resetHandlers();
 	});
 
-	it('loads and displays active users and pending invites', async () => {
+	it('loads and displays active users, pending invites, and deleted members', async () => {
 		render(<MembersSettings />);
 
 		await screen.findByText('Alice Smith');
 		expect(screen.getByText('Bob Jones')).toBeInTheDocument();
 		expect(screen.getByText('charlie@signoz.io')).toBeInTheDocument();
+		expect(screen.getByText('Dave Deleted')).toBeInTheDocument();
 		expect(screen.getAllByText('ACTIVE')).toHaveLength(2);
 		expect(screen.getByText('INVITED')).toBeInTheDocument();
+		expect(screen.getByText('DELETED')).toBeInTheDocument();
 	});
 
 	it('filters to pending invites via the filter dropdown', async () => {
@@ -107,7 +115,7 @@ describe('MembersSettings (integration)', () => {
 		expect(screen.queryByText('charlie@signoz.io')).not.toBeInTheDocument();
 	});
 
-	it('opens EditMemberDrawer when a member row is clicked', async () => {
+	it('opens EditMemberDrawer when an active member row is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		render(<MembersSettings />);
@@ -117,6 +125,16 @@ describe('MembersSettings (integration)', () => {
 		await screen.findByText('Member Details');
 	});
 
+	it('does not open EditMemberDrawer when a deleted member row is clicked', async () => {
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+
+		render(<MembersSettings />);
+
+		await user.click(await screen.findByText('Dave Deleted'));
+
+		expect(screen.queryByText('Member Details')).not.toBeInTheDocument();
+	});
+
 	it('opens InviteMembersModal when "Invite member" button is clicked', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 

frontend/src/container/MembersSettings/utils.ts

@@ -1,5 +1,3 @@
-export const INVITE_PREFIX = 'invite-';
-
 export enum FilterMode {
 	All = 'all',
 	Invited = 'invited',
@@ -8,4 +6,25 @@ export enum FilterMode {
 export enum MemberStatus {
 	Active = 'Active',
 	Invited = 'Invited',
+	Deleted = 'Deleted',
+	Anonymous = 'Anonymous',
+}
+
+export enum UserApiStatus {
+	Active = 'active',
+	PendingInvite = 'pending_invite',
+	Deleted = 'deleted',
+}
+
+export function toMemberStatus(apiStatus: string): MemberStatus {
+	switch (apiStatus) {
+		case UserApiStatus.PendingInvite:
+			return MemberStatus.Invited;
+		case UserApiStatus.Deleted:
+			return MemberStatus.Deleted;
+		case UserApiStatus.Active:
+			return MemberStatus.Active;
+		default:
+			return MemberStatus.Anonymous;
+	}
 }

frontend/src/hooks/useAuthZ/constants.ts

@@ -1,2 +0,0 @@
-export const SINGLE_FLIGHT_WAIT_TIME_MS = 50;
-export const AUTHZ_CACHE_TIME = 20_000;

frontend/src/hooks/useAuthZ/legacy.ts

@@ -1,18 +0,0 @@
-import { buildPermission } from './utils';
-
-export const IsAdminPermission = buildPermission(
-	'assignee',
-	'role:signoz-admin',
-);
-export const IsEditorPermission = buildPermission(
-	'assignee',
-	'role:signoz-editor',
-);
-export const IsViewerPermission = buildPermission(
-	'assignee',
-	'role:signoz-viewer',
-);
-export const IsAnonymousPermission = buildPermission(
-	'assignee',
-	'role:signoz-anonymous',
-);

frontend/src/hooks/useAuthZ/types.ts

@@ -14,7 +14,7 @@ type ResourceTypeMap = {
 
 type RelationName = keyof RelationsByType;
 
-export type ResourcesForRelation<R extends RelationName> = Extract<
+type ResourcesForRelation<R extends RelationName> = Extract<
 	Resource,
 	{ type: RelationsByType[R][number] }
 >['name'];
@@ -50,26 +50,8 @@ export type AuthZCheckResponse = Record<
 	}
 >;
 
-export type UseAuthZOptions = {
-	/**
-	 * If false, the query/permissions will not be fetched.
-	 * Useful when you want to disable the query/permissions for a specific use case, like logout.
-	 *
-	 * @default true
-	 */
-	enabled?: boolean;
-};
-
 export type UseAuthZResult = {
-	/**
-	 * If query is cached, and refetch happens in background, this is false.
-	 */
 	isLoading: boolean;
-	/**
-	 * If query is fetching, even if happens in background, this is true.
-	 */
-	isFetching: boolean;
 	error: Error | null;
 	permissions: AuthZCheckResponse | null;
-	refetchPermissions: () => void;
 };

frontend/src/hooks/useAuthZ/useAuthZ.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import { useMemo } from 'react';
 import { useQueries } from 'react-query';
 import { authzCheck } from 'api/generated/services/authz';
 import type {
@@ -6,13 +6,7 @@ import type {
 	AuthtypesTransactionDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
-import { AUTHZ_CACHE_TIME, SINGLE_FLIGHT_WAIT_TIME_MS } from './constants';
-import {
-	AuthZCheckResponse,
-	BrandedPermission,
-	UseAuthZOptions,
-	UseAuthZResult,
-} from './types';
+import { AuthZCheckResponse, BrandedPermission, UseAuthZResult } from './types';
 import {
 	gettableTransactionToPermission,
 	permissionToTransactionDto,
@@ -20,6 +14,8 @@ import {
 
 let ctx: Promise<AuthZCheckResponse> | null;
 let pendingPermissions: BrandedPermission[] = [];
+const SINGLE_FLIGHT_WAIT_TIME_MS = 50;
+const AUTHZ_CACHE_TIME = 20_000;
 
 function dispatchPermission(
 	permission: BrandedPermission,
@@ -74,12 +70,7 @@ async function fetchManyPermissions(
 	}, {} as AuthZCheckResponse);
 }
 
-export function useAuthZ(
-	permissions: BrandedPermission[],
-	options?: UseAuthZOptions,
-): UseAuthZResult {
-	const { enabled } = options ?? { enabled: true };
-
+export function useAuthZ(permissions: BrandedPermission[]): UseAuthZResult {
 	const queryResults = useQueries(
 		permissions.map((permission) => {
 			return {
@@ -89,7 +80,6 @@ export function useAuthZ(
 				refetchIntervalInBackground: false,
 				refetchOnWindowFocus: false,
 				refetchOnReconnect: true,
-				enabled,
 				queryFn: async (): Promise<AuthZCheckResponse> => {
 					const response = await dispatchPermission(permission);
 
@@ -106,10 +96,6 @@ export function useAuthZ(
 	const isLoading = useMemo(() => queryResults.some((q) => q.isLoading), [
 		queryResults,
 	]);
-	const isFetching = useMemo(() => queryResults.some((q) => q.isFetching), [
-		queryResults,
-	]);
-
 	const error = useMemo(
 		() =>
 			!isLoading
@@ -135,17 +121,9 @@ export function useAuthZ(
 		}, {} as AuthZCheckResponse);
 	}, [isLoading, error, queryResults]);
 
-	const refetchPermissions = useCallback(() => {
-		for (const query of queryResults) {
-			query.refetch();
-		}
-	}, [queryResults]);
-
 	return {
 		isLoading,
-		isFetching,
 		error,
 		permissions: data ?? null,
-		refetchPermissions,
 	};
 }

frontend/src/hooks/useAuthZ/utils.ts

@@ -3,9 +3,9 @@ import permissionsType from './permissions.type';
 import {
 	AuthZObject,
 	AuthZRelation,
+	AuthZResource,
 	BrandedPermission,
 	ResourceName,
-	ResourcesForRelation,
 	ResourceType,
 } from './types';
 
@@ -19,10 +19,11 @@ export function buildPermission<R extends AuthZRelation>(
 	return `${relation}${PermissionSeparator}${object}` as BrandedPermission;
 }
 
-export function buildObjectString<
-	R extends 'delete' | 'read' | 'update' | 'assignee'
->(resource: ResourcesForRelation<R>, objectId: string): AuthZObject<R> {
-	return `${resource}${ObjectSeparator}${objectId}` as AuthZObject<R>;
+export function buildObjectString(
+	resource: AuthZResource,
+	objectId: string,
+): `${AuthZResource}${typeof ObjectSeparator}${string}` {
+	return `${resource}${ObjectSeparator}${objectId}` as const;
 }
 
 export function parsePermission(

frontend/src/mocks-server/__mockdata__/invite_user.ts

@@ -1,25 +0,0 @@
-export const inviteUser = {
-	status: 'success',
-	data: {
-		statusCode: 200,
-		error: null,
-		payload: [
-			{
-				email: 'jane@doe.com',
-				name: 'Jane',
-				token: 'testtoken',
-				createdAt: 1715741587,
-				role: 'VIEWER',
-				organization: 'test',
-			},
-			{
-				email: 'test+in@singoz.io',
-				name: '',
-				token: 'testtoken1',
-				createdAt: 1720095913,
-				role: 'VIEWER',
-				organization: 'test',
-			},
-		],
-	},
-};

frontend/src/mocks-server/handlers.ts

@@ -9,7 +9,6 @@ import {
 	getDashboardById,
 } from './__mockdata__/dashboards';
 import { explorerView } from './__mockdata__/explorer_views';
-import { inviteUser } from './__mockdata__/invite_user';
 import { licensesSuccessResponse } from './__mockdata__/licenses';
 import { membersResponse } from './__mockdata__/members';
 import { queryRangeSuccessResponse } from './__mockdata__/query_range';
@@ -175,11 +174,14 @@ export const handlers = [
 		res(ctx.status(200), ctx.json(getDashboardById)),
 	),
 
-	rest.get('http://localhost/api/v1/invite', (_, res, ctx) =>
-		res(ctx.status(200), ctx.json(inviteUser)),
-	),
 	rest.post('http://localhost/api/v1/invite', (_, res, ctx) =>
-		res(ctx.status(200), ctx.json(inviteUser)),
+		res(
+			ctx.status(200),
+			ctx.json({
+				status: 'success',
+				data: 'invite sent successfully',
+			}),
+		),
 	),
 	rest.put('http://localhost/api/v1/user/:id', (_, res, ctx) =>
 		res(

frontend/src/pages/SignUp/SignUp.tsx

@@ -1,13 +1,9 @@
-import { useEffect, useMemo, useState } from 'react';
-import { useQuery } from 'react-query';
-import { useLocation } from 'react-router-dom';
+import { useMemo, useState } from 'react';
 import { Button } from '@signozhq/button';
 import { Callout } from '@signozhq/callout';
 import { Input } from '@signozhq/input';
 import { Form, Input as AntdInput, Typography } from 'antd';
 import logEvent from 'api/common/logEvent';
-import accept from 'api/v1/invite/id/accept';
-import getInviteDetails from 'api/v1/invite/id/get';
 import signUpApi from 'api/v1/register/post';
 import passwordAuthNContext from 'api/v2/sessions/email_password/post';
 import afterLogin from 'AppRoutes/utils';
@@ -15,9 +11,7 @@ import AuthError from 'components/AuthError/AuthError';
 import AuthPageContainer from 'components/AuthPageContainer';
 import { useNotifications } from 'hooks/useNotifications';
 import { ArrowRight, CircleAlert } from 'lucide-react';
-import { SuccessResponseV2 } from 'types/api';
 import APIError from 'types/api/error';
-import { InviteDetails } from 'types/api/user/getInviteDetails';
 
 import { FormContainer, Label } from './styles';
 
@@ -39,22 +33,6 @@ function SignUp(): JSX.Element {
 		false,
 	);
 	const [formError, setFormError] = useState<APIError | null>();
-	const { search } = useLocation();
-	const params = new URLSearchParams(search);
-	const token = params.get('token');
-	const [isDetailsDisable, setIsDetailsDisable] = useState<boolean>(false);
-
-	const getInviteDetailsResponse = useQuery<
-		SuccessResponseV2<InviteDetails>,
-		APIError
-	>({
-		queryFn: () =>
-			getInviteDetails({
-				inviteId: token || '',
-			}),
-		queryKey: ['getInviteDetails', token],
-		enabled: token !== null,
-	});
 
 	const { notifications } = useNotifications();
 	const [form] = Form.useForm<FormValues>();
@@ -64,49 +42,6 @@ function SignUp(): JSX.Element {
 	const password = Form.useWatch('password', form);
 	const confirmPassword = Form.useWatch('confirmPassword', form);
 
-	useEffect(() => {
-		if (
-			getInviteDetailsResponse.status === 'success' &&
-			getInviteDetailsResponse.data.data
-		) {
-			const responseDetails = getInviteDetailsResponse.data.data;
-			form.setFieldValue('email', responseDetails.email);
-			form.setFieldValue('organizationName', responseDetails.organization);
-			setIsDetailsDisable(true);
-
-			logEvent('Account Creation Page Visited', {
-				email: responseDetails.email,
-				name: responseDetails.name,
-				company_name: responseDetails.organization,
-				source: 'SigNoz Cloud',
-			});
-		}
-	}, [
-		getInviteDetailsResponse.data?.data,
-		form,
-		getInviteDetailsResponse.status,
-	]);
-
-	useEffect(() => {
-		if (
-			getInviteDetailsResponse.status === 'success' &&
-			getInviteDetailsResponse?.error
-		) {
-			const { error } = getInviteDetailsResponse;
-			notifications.error({
-				message: (error as APIError).getErrorCode(),
-				description: (error as APIError).getErrorMessage(),
-			});
-		}
-	}, [
-		getInviteDetailsResponse,
-		getInviteDetailsResponse.data,
-		getInviteDetailsResponse.status,
-		notifications,
-	]);
-
-	const isSignUp = token === null;
-
 	const signUp = async (values: FormValues): Promise<void> => {
 		try {
 			const { organizationName, password, email } = values;
@@ -114,7 +49,6 @@ function SignUp(): JSX.Element {
 				email,
 				orgDisplayName: organizationName,
 				password,
-				token: params.get('token') || undefined,
 			});
 
 			const token = await passwordAuthNContext({
@@ -129,25 +63,6 @@ function SignUp(): JSX.Element {
 		}
 	};
 
-	const acceptInvite = async (values: FormValues): Promise<void> => {
-		try {
-			const { password, email } = values;
-			const user = await accept({
-				password,
-				token: params.get('token') || '',
-			});
-			const token = await passwordAuthNContext({
-				email,
-				password,
-				orgId: user.data.orgId,
-			});
-
-			await afterLogin(token.data.accessToken, token.data.refreshToken);
-		} catch (error) {
-			setFormError(error as APIError);
-		}
-	};
-
 	const handleSubmit = (): void => {
 		(async (): Promise<void> => {
 			try {
@@ -155,14 +70,10 @@ function SignUp(): JSX.Element {
 				setLoading(true);
 				setFormError(null);
 
-				if (isSignUp) {
-					await signUp(values);
-					logEvent('Account Created Successfully', {
-						email: values.email,
-					});
-				} else {
-					await acceptInvite(values);
-				}
+				await signUp(values);
+				logEvent('Account Created Successfully', {
+					email: values.email,
+				});
 
 				setLoading(false);
 			} catch (error) {
@@ -247,7 +158,6 @@ function SignUp(): JSX.Element {
 										autoFocus
 										required
 										id="signupEmail"
-										disabled={isDetailsDisable}
 										className="signup-form-input"
 									/>
 								</FormContainer.Item>
@@ -291,15 +201,13 @@ function SignUp(): JSX.Element {
 						</div>
 					</div>
 
-					{isSignUp && (
-						<Callout
-							type="info"
-							size="small"
-							showIcon
-							className="signup-info-callout"
-							description="This will create an admin account. If you are not an admin, please ask your admin for an invite link"
-						/>
-					)}
+					<Callout
+						type="info"
+						size="small"
+						showIcon
+						className="signup-info-callout"
+						description="This will create an admin account. If you are not an admin, please ask your admin for an invite link"
+					/>
 
 					{confirmPasswordError && (
 						<Callout

frontend/src/pages/SignUp/__tests__/SignUp.test.tsx

@@ -1,7 +1,6 @@
 import afterLogin from 'AppRoutes/utils';
 import { rest, server } from 'mocks-server/server';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
-import { InviteDetails } from 'types/api/user/getInviteDetails';
 import { SignupResponse } from 'types/api/v1/register/post';
 import { Token } from 'types/api/v2/sessions/email_password/post';
 
@@ -32,14 +31,8 @@ jest.mock('lib/history', () => ({
 
 const REGISTER_ENDPOINT = '*/api/v1/register';
 const EMAIL_PASSWORD_ENDPOINT = '*/api/v2/sessions/email_password';
-const INVITE_DETAILS_ENDPOINT = '*/api/v1/invite/*';
-const ACCEPT_INVITE_ENDPOINT = '*/api/v1/invite/accept';
 
-interface MockSignupResponse extends SignupResponse {
-	orgId: string;
-}
-
-const mockSignupResponse: MockSignupResponse = {
+const mockSignupResponse: SignupResponse = {
 	orgId: 'test-org-id',
 	createdAt: Date.now(),
 	email: 'test@signoz.io',
@@ -53,15 +46,6 @@ const mockTokenResponse: Token = {
 	refreshToken: 'mock-refresh-token',
 };
 
-const mockInviteDetails: InviteDetails = {
-	email: 'invited@signoz.io',
-	name: 'Invited User',
-	organization: 'Test Org',
-	createdAt: Date.now(),
-	role: 'ADMIN',
-	token: 'invite-token-123',
-};
-
 describe('SignUp Component - Regular Signup', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
@@ -288,242 +272,3 @@ describe('SignUp Component - Regular Signup', () => {
 		});
 	});
 });
-
-describe('SignUp Component - Accept Invite', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		window.history.pushState({}, '', '/signup?token=invite-token-123');
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	describe('Initial Render with Invite', () => {
-		it('pre-fills form fields from invite details', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-		});
-
-		it('disables email field when invite details are loaded', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			await waitFor(() => {
-				expect(emailInput).toBeDisabled();
-			});
-		});
-
-		it('does not show admin account info callout for invite flow', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			await waitFor(() => {
-				expect(
-					screen.queryByText(/this will create an admin account/i),
-				).not.toBeInTheDocument();
-			});
-		});
-	});
-
-	describe('Successful Invite Acceptance', () => {
-		it('successfully accepts invite and logs in user', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(ACCEPT_INVITE_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockSignupResponse,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(EMAIL_PASSWORD_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockTokenResponse,
-							status: 'success',
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invite-token-123',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-
-			const passwordInput = screen.getByPlaceholderText(/enter new password/i);
-			const confirmPasswordInput = screen.getByPlaceholderText(
-				/confirm your new password/i,
-			);
-			const submitButton = screen.getByRole('button', {
-				name: /access my workspace/i,
-			});
-
-			await user.type(passwordInput, 'password123');
-			await user.type(confirmPasswordInput, 'password123');
-
-			await waitFor(() => {
-				expect(submitButton).not.toBeDisabled();
-			});
-
-			await user.click(submitButton);
-
-			await waitFor(() => {
-				expect(mockAfterLogin).toHaveBeenCalledWith(
-					'mock-access-token',
-					'mock-refresh-token',
-				);
-			});
-		});
-	});
-
-	describe('Error Handling for Invite', () => {
-		it('displays error when invite details fetch fails', async () => {
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(404),
-						ctx.json({
-							error: {
-								code: 'INVITE_NOT_FOUND',
-								message: 'Invite not found',
-							},
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=invalid-token',
-			});
-
-			// Verify form is still accessible and fields are enabled
-			const emailInput = await screen.findByLabelText(/email address/i);
-
-			expect(emailInput).toBeInTheDocument();
-			expect(emailInput).not.toBeDisabled();
-		});
-
-		it('displays error when accept invite API fails', async () => {
-			const user = userEvent.setup({ pointerEventsCheck: 0 });
-
-			server.use(
-				rest.get(INVITE_DETAILS_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(200),
-						ctx.json({
-							data: mockInviteDetails,
-							status: 'success',
-						}),
-					),
-				),
-				rest.post(ACCEPT_INVITE_ENDPOINT, (_req, res, ctx) =>
-					res(
-						ctx.status(400),
-						ctx.json({
-							error: {
-								code: 'INVALID_TOKEN',
-								message: 'Invalid or expired invite token',
-							},
-						}),
-					),
-				),
-			);
-
-			render(<SignUp />, undefined, {
-				initialRoute: '/signup?token=expired-token',
-			});
-
-			const emailInput = await screen.findByLabelText(/email address/i);
-			await waitFor(() => {
-				expect(emailInput).toHaveValue('invited@signoz.io');
-			});
-
-			const passwordInput = screen.getByPlaceholderText(/enter new password/i);
-			const confirmPasswordInput = screen.getByPlaceholderText(
-				/confirm your new password/i,
-			);
-			const submitButton = screen.getByRole('button', {
-				name: /access my workspace/i,
-			});
-
-			await user.type(passwordInput, 'password123');
-			await user.type(confirmPasswordInput, 'password123');
-
-			await waitFor(() => {
-				expect(submitButton).not.toBeDisabled();
-			});
-
-			await user.click(submitButton);
-
-			expect(
-				await screen.findByText(/invalid or expired invite token/i),
-			).toBeInTheDocument();
-		});
-	});
-});

frontend/src/pages/UnAuthorized/index.styles.scss

@@ -1,5 +0,0 @@
-.unauthorized-page {
-	&__description {
-		text-align: center;
-	}
-}

frontend/src/pages/UnAuthorized/index.tsx

@@ -1,51 +1,20 @@
-import { useCallback } from 'react';
 import { Space, Typography } from 'antd';
 import UnAuthorized from 'assets/UnAuthorized';
-import { Container } from 'components/NotFound/styles';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-import { useQueryState } from 'nuqs';
-import { handleContactSupport } from 'pages/Integrations/utils';
-
-import { useAppContext } from '../../providers/App/App';
-import { USER_ROLES } from '../../types/roles';
-
-import './index.styles.scss';
+import { Button, Container } from 'components/NotFound/styles';
+import ROUTES from 'constants/routes';
 
 function UnAuthorizePage(): JSX.Element {
-	const [debugCurrentRole] = useQueryState('currentRole');
-	const { user } = useAppContext();
-	const { isCloudUser: isCloudUserVal } = useGetTenantLicense();
-
-	const userIsAnonymous =
-		debugCurrentRole === USER_ROLES.ANONYMOUS ||
-		user.role === USER_ROLES.ANONYMOUS;
-	const mistakeMessage = userIsAnonymous
-		? 'If you believe this is a mistake, please contact your administrator or'
-		: 'Please contact your administrator.';
-
-	const handleContactSupportClick = useCallback((): void => {
-		handleContactSupport(isCloudUserVal);
-	}, [isCloudUserVal]);
-
 	return (
-		<Container className="unauthorized-page">
+		<Container>
 			<Space align="center" direction="vertical">
-				<UnAuthorized width={64} height={64} />
-				<Typography.Title level={3}>Access Restricted</Typography.Title>
+				<UnAuthorized />
+				<Typography.Title level={3}>
+					Oops.. you don&apos;t have permission to view this page
+				</Typography.Title>
 
-				<p className="unauthorized-page__description">
-					It looks like you don&lsquo;t have permission to view this page. <br />
-					{mistakeMessage}
-					{userIsAnonymous ? (
-						<Typography.Link
-							className="contact-support-link"
-							onClick={handleContactSupportClick}
-						>
-							{' '}
-							reach out to us.
-						</Typography.Link>
-					) : null}
-				</p>
+				<Button to={ROUTES.HOME} tabIndex={0} className="periscope-btn primary">
+					Return To Home
+				</Button>
 			</Space>
 		</Container>
 	);

frontend/src/providers/App/App.tsx

@@ -19,12 +19,6 @@ import getUserVersion from 'api/v1/version/get';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import dayjs from 'dayjs';
 import useActiveLicenseV3 from 'hooks/useActiveLicenseV3/useActiveLicenseV3';
-import {
-	IsAdminPermission,
-	IsEditorPermission,
-	IsViewerPermission,
-} from 'hooks/useAuthZ/legacy';
-import { useAuthZ } from 'hooks/useAuthZ/useAuthZ';
 import { useGetFeatureFlag } from 'hooks/useGetFeatureFlag';
 import { useGlobalEventListener } from 'hooks/useGlobalEventListener';
 import { ChangelogSchema } from 'types/api/changelog/getChangelogByVersion';
@@ -40,7 +34,7 @@ import {
 	UserPreference,
 } from 'types/api/preferences/preference';
 import { Organization } from 'types/api/user/getOrganization';
-import { ROLES, USER_ROLES } from 'types/roles';
+import { USER_ROLES } from 'types/roles';
 
 import { IAppContext, IUser } from './types';
 import { getUserDefaults } from './utils';
@@ -49,7 +43,7 @@ export const AppContext = createContext<IAppContext | undefined>(undefined);
 
 export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// on load of the provider set the user defaults with access token , refresh token from local storage
-	const [defaultUser, setDefaultUser] = useState<IUser>(() => getUserDefaults());
+	const [user, setUser] = useState<IUser>(() => getUserDefaults());
 	const [activeLicense, setActiveLicense] = useState<LicenseResModel | null>(
 		null,
 	);
@@ -76,51 +70,18 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// if logged out and trying to hit any route none of these calls will trigger
 	const {
 		data: userData,
-		isFetching: isFetchingUserData,
-		error: userFetchDataError,
+		isFetching: isFetchingUser,
+		error: userFetchError,
 	} = useQuery({
 		queryFn: get,
 		queryKey: ['/api/v1/user/me'],
 		enabled: isLoggedIn,
 	});
 
-	const {
-		permissions: permissionsResult,
-		isFetching: isFetchingPermissions,
-		error: errorOnPermissions,
-		refetchPermissions,
-	} = useAuthZ([IsAdminPermission, IsEditorPermission, IsViewerPermission], {
-		enabled: isLoggedIn,
-	});
-
-	const isFetchingUser = isFetchingUserData || isFetchingPermissions;
-	const userFetchError = userFetchDataError || errorOnPermissions;
-
-	const userRole = useMemo(() => {
-		if (permissionsResult?.[IsAdminPermission]?.isGranted) {
-			return USER_ROLES.ADMIN;
-		}
-		if (permissionsResult?.[IsEditorPermission]?.isGranted) {
-			return USER_ROLES.EDITOR;
-		}
-		if (permissionsResult?.[IsViewerPermission]?.isGranted) {
-			return USER_ROLES.VIEWER;
-		}
-		// if none of the permissions, so anonymous
-		return USER_ROLES.ANONYMOUS;
-	}, [permissionsResult]);
-
-	const user: IUser = useMemo(() => {
-		return {
-			...defaultUser,
-			role: userRole as ROLES,
-		};
-	}, [defaultUser, userRole]);
-
 	useEffect(() => {
 		if (!isFetchingUser && userData && userData.data) {
 			setLocalStorageApi(LOCALSTORAGE.LOGGED_IN_USER_EMAIL, userData.data.email);
-			setDefaultUser((prev) => ({
+			setUser((prev) => ({
 				...prev,
 				...userData.data,
 			}));
@@ -242,7 +203,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	}, [userPreferencesData, isFetchingUserPreferences, isLoggedIn]);
 
 	function updateUser(user: IUser): void {
-		setDefaultUser((prev) => ({
+		setUser((prev) => ({
 			...prev,
 			...user,
 		}));
@@ -283,7 +244,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 					...org.slice(orgIndex + 1, org.length),
 				];
 				setOrg(updatedOrg);
-				setDefaultUser((prev) => {
+				setUser((prev) => {
 					if (prev.orgId === orgId) {
 						return {
 							...prev,
@@ -311,7 +272,7 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 	// global event listener for AFTER_LOGIN event to start the user fetch post all actions are complete
 	useGlobalEventListener('AFTER_LOGIN', (event) => {
 		if (event.detail) {
-			setDefaultUser((prev) => ({
+			setUser((prev) => ({
 				...prev,
 				accessJwt: event.detail.accessJWT,
 				refreshJwt: event.detail.refreshJWT,
@@ -319,14 +280,12 @@ export function AppProvider({ children }: PropsWithChildren): JSX.Element {
 			}));
 			setIsLoggedIn(true);
 		}
-
-		refetchPermissions();
 	});
 
 	// global event listener for LOGOUT event to clean the app context state
 	useGlobalEventListener('LOGOUT', () => {
 		setIsLoggedIn(false);
-		setDefaultUser(getUserDefaults());
+		setUser(getUserDefaults());
 		setActiveLicense(null);
 		setTrialInfo(null);
 		setFeatureFlags(null);

frontend/src/providers/App/__tests__/App.test.tsx

@@ -1,273 +0,0 @@
-import { ReactElement } from 'react';
-import { QueryClient, QueryClientProvider } from 'react-query';
-import { renderHook, waitFor } from '@testing-library/react';
-import setLocalStorageApi from 'api/browser/localstorage/set';
-import {
-	AuthtypesGettableTransactionDTO,
-	AuthtypesTransactionDTO,
-} from 'api/generated/services/sigNoz.schemas';
-import { LOCALSTORAGE } from 'constants/localStorage';
-import { SINGLE_FLIGHT_WAIT_TIME_MS } from 'hooks/useAuthZ/constants';
-import { server } from 'mocks-server/server';
-import { rest } from 'msw';
-import { USER_ROLES } from 'types/roles';
-
-import { AppProvider, useAppContext } from '../App';
-
-const AUTHZ_CHECK_URL = 'http://localhost/api/v1/authz/check';
-
-jest.mock('constants/env', () => ({
-	ENVIRONMENT: { baseURL: 'http://localhost', wsURL: '' },
-}));
-
-/**
- * Since we are mocking the check permissions, this is needed
- */
-const waitForSinglePreflightToFinish = async (): Promise<void> =>
-	await new Promise((r) => setTimeout(r, SINGLE_FLIGHT_WAIT_TIME_MS));
-
-function authzMockResponse(
-	payload: AuthtypesTransactionDTO[],
-	authorizedByIndex: boolean[],
-): { data: AuthtypesGettableTransactionDTO[]; status: string } {
-	return {
-		data: payload.map((txn, i) => ({
-			relation: txn.relation,
-			object: txn.object,
-			authorized: authorizedByIndex[i] ?? false,
-		})),
-		status: 'success',
-	};
-}
-
-const queryClient = new QueryClient({
-	defaultOptions: {
-		queries: {
-			refetchOnWindowFocus: false,
-			retry: false,
-		},
-	},
-});
-
-function createWrapper(): ({
-	children,
-}: {
-	children: ReactElement;
-}) => ReactElement {
-	return function Wrapper({
-		children,
-	}: {
-		children: ReactElement;
-	}): ReactElement {
-		return (
-			<QueryClientProvider client={queryClient}>
-				<AppProvider>{children}</AppProvider>
-			</QueryClientProvider>
-		);
-	};
-}
-
-describe('AppProvider user.role from permissions', () => {
-	beforeEach(() => {
-		queryClient.clear();
-		setLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN, 'true');
-	});
-
-	it('sets user.role to ADMIN and hasEditPermission to true when admin permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [true, false, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.ADMIN);
-				expect(result.current.hasEditPermission).toBe(true);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to EDITOR and hasEditPermission to true when only editor permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, true, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.EDITOR);
-				expect(result.current.hasEditPermission).toBe(true);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to VIEWER and hasEditPermission to false when only viewer permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, false, true])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.VIEWER);
-				expect(result.current.hasEditPermission).toBe(false);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets user.role to ANONYMOUS and hasEditPermission to false when no role permission is granted', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-				const payload = await req.json();
-				return res(
-					ctx.status(200),
-					ctx.json(authzMockResponse(payload, [false, false, false])),
-				);
-			}),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.user.role).toBe(USER_ROLES.ANONYMOUS);
-				expect(result.current.hasEditPermission).toBe(false);
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	/**
-	 * This is expected to not happen, but we'll test it just in case.
-	 */
-	describe('when multiple role permissions are granted', () => {
-		it('prefers ADMIN over EDITOR and VIEWER when multiple role permissions are granted', async () => {
-			server.use(
-				rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-					const payload = await req.json();
-					return res(
-						ctx.status(200),
-						ctx.json(authzMockResponse(payload, [true, true, true])),
-					);
-				}),
-			);
-
-			const wrapper = createWrapper();
-			const { result } = renderHook(() => useAppContext(), { wrapper });
-
-			await waitFor(
-				() => {
-					expect(result.current.user.role).toBe(USER_ROLES.ADMIN);
-					expect(result.current.hasEditPermission).toBe(true);
-				},
-				{ timeout: 300 },
-			);
-		});
-
-		it('prefers EDITOR over VIEWER when editor and viewer permissions are granted', async () => {
-			server.use(
-				rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
-					const payload = await req.json();
-					return res(
-						ctx.status(200),
-						ctx.json(authzMockResponse(payload, [false, true, true])),
-					);
-				}),
-			);
-
-			const wrapper = createWrapper();
-			const { result } = renderHook(() => useAppContext(), { wrapper });
-
-			await waitForSinglePreflightToFinish();
-
-			await waitFor(
-				() => {
-					expect(result.current.user.role).toBe(USER_ROLES.EDITOR);
-					expect(result.current.hasEditPermission).toBe(true);
-				},
-				{ timeout: 2000 },
-			);
-		});
-	});
-});
-
-describe('AppProvider when authz/check fails', () => {
-	beforeEach(() => {
-		queryClient.clear();
-		setLocalStorageApi(LOCALSTORAGE.IS_LOGGED_IN, 'true');
-	});
-
-	it('sets userFetchError when authz/check returns 500 (same as user fetch error)', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, (_, res, ctx) =>
-				res(ctx.status(500), ctx.json({ error: 'Internal Server Error' })),
-			),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.userFetchError).toBeTruthy();
-			},
-			{ timeout: 2000 },
-		);
-	});
-
-	it('sets userFetchError when authz/check fails with network error (same as user fetch error)', async () => {
-		server.use(
-			rest.post(AUTHZ_CHECK_URL, (_, res) => res.networkError('Network error')),
-		);
-
-		const wrapper = createWrapper();
-		const { result } = renderHook(() => useAppContext(), { wrapper });
-
-		await waitForSinglePreflightToFinish();
-
-		await waitFor(
-			() => {
-				expect(result.current.userFetchError).toBeTruthy();
-			},
-			{ timeout: 2000 },
-		);
-	});
-});

frontend/src/types/api/user/accept.ts

@@ -1,20 +0,0 @@
-import { UserResponse } from './getUser';
-
-export interface Props {
-	token: string;
-	password: string;
-	displayName?: string;
-	sourceUrl?: string;
-}
-
-export interface LoginPrecheckResponse {
-	sso: boolean;
-	ssoUrl?: string;
-	canSelfRegister?: boolean;
-	isUser: boolean;
-}
-
-export interface PayloadProps {
-	data: UserResponse;
-	status: string;
-}

frontend/src/types/api/user/deleteInvite.ts

@@ -1,7 +0,0 @@
-export interface Props {
-	id: string;
-}
-
-export interface PayloadProps {
-	data: string;
-}

frontend/src/types/api/user/getInviteDetails.ts

@@ -1,22 +0,0 @@
-import { User } from 'types/reducer/app';
-import { ROLES } from 'types/roles';
-
-import { Organization } from './getOrganization';
-
-export interface Props {
-	inviteId: string;
-}
-
-export interface PayloadProps {
-	data: InviteDetails;
-	status: string;
-}
-
-export interface InviteDetails {
-	createdAt: number;
-	email: User['email'];
-	name: User['displayName'];
-	role: ROLES;
-	token: string;
-	organization: Organization['displayName'];
-}

frontend/src/types/api/user/getPendingInvites.ts

@@ -1,16 +0,0 @@
-import { User } from 'types/reducer/app';
-import { ROLES } from 'types/roles';
-
-export interface PendingInvite {
-	createdAt: number;
-	email: User['email'];
-	name: User['displayName'];
-	role: ROLES;
-	id: string;
-	token: string;
-}
-
-export type PayloadProps = {
-	data: PendingInvite[];
-	status: string;
-};

frontend/src/types/api/user/getUser.ts

@@ -7,17 +7,16 @@ export interface Props {
 }
 
 export interface UserResponse {
-	createdAt: number;
+	createdAt: number | string;
 	email: string;
 	id: string;
 	displayName: string;
 	orgId: string;
 	organization: string;
-	/**
-	 * @deprecated This will be removed in the future releases in favor of new AuthZ framework
-	 */
 	role: ROLES;
-	updatedAt?: number;
+	updatedAt?: number | string;
+	isRoot?: boolean;
+	status?: 'active' | 'pending_invite' | 'deleted';
 }
 export interface PayloadProps {
 	data: UserResponse;

frontend/src/types/roles.ts

@@ -2,16 +2,14 @@ export type ADMIN = 'ADMIN';
 export type VIEWER = 'VIEWER';
 export type EDITOR = 'EDITOR';
 export type AUTHOR = 'AUTHOR';
-export type ANONYMOUS = 'ANONYMOUS';
 
-export type ROLES = ADMIN | VIEWER | EDITOR | AUTHOR | ANONYMOUS;
+export type ROLES = ADMIN | VIEWER | EDITOR | AUTHOR;
 
 export const USER_ROLES = {
 	ADMIN: 'ADMIN',
 	VIEWER: 'VIEWER',
 	EDITOR: 'EDITOR',
 	AUTHOR: 'AUTHOR',
-	ANONYMOUS: 'ANONYMOUS',
 };
 
 export enum RoleType {

frontend/src/utils/permission/index.ts

@@ -69,7 +69,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	ALERT_OVERVIEW: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGIN: ['ADMIN', 'EDITOR', 'VIEWER'],
 	FORGOT_PASSWORD: ['ADMIN', 'EDITOR', 'VIEWER'],
-	NOT_FOUND: ['ADMIN', 'VIEWER', 'EDITOR', 'ANONYMOUS'],
+	NOT_FOUND: ['ADMIN', 'VIEWER', 'EDITOR'],
 	PASSWORD_RESET: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SERVICE_METRICS: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SETTINGS: ['ADMIN', 'EDITOR', 'VIEWER'],
@@ -77,7 +77,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	TRACES_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACE: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACE_DETAIL: ['ADMIN', 'EDITOR', 'VIEWER'],
-	UN_AUTHORIZED: ['ADMIN', 'EDITOR', 'VIEWER', 'ANONYMOUS'],
+	UN_AUTHORIZED: ['ADMIN', 'EDITOR', 'VIEWER'],
 	USAGE_EXPLORER: ['ADMIN', 'EDITOR', 'VIEWER'],
 	VERSION: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGS: ['ADMIN', 'EDITOR', 'VIEWER'],
@@ -101,7 +101,7 @@ export const routePermission: Record<keyof typeof ROUTES, ROLES[]> = {
 	ROLE_DETAILS: ['ADMIN'],
 	MEMBERS_SETTINGS: ['ADMIN'],
 	BILLING: ['ADMIN'],
-	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER', 'ANONYMOUS'],
+	SUPPORT: ['ADMIN', 'EDITOR', 'VIEWER'],
 	SOMETHING_WENT_WRONG: ['ADMIN', 'EDITOR', 'VIEWER'],
 	LOGS_SAVE_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],
 	TRACES_SAVE_VIEWS: ['ADMIN', 'EDITOR', 'VIEWER'],

pkg/apiserver/signozapiserver/user.go

@@ -43,74 +43,6 @@ func (provider *provider) addUserRoutes(router *mux.Router) error {
 		return err
 	}
 
-	if err := router.Handle("/api/v1/invite/{token}", handler.New(provider.authZ.OpenAccess(provider.userHandler.GetInvite), handler.OpenAPIDef{
-		ID:                  "GetInvite",
-		Tags:                []string{"users"},
-		Summary:             "Get invite",
-		Description:         "This endpoint gets an invite by token",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(types.Invite),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     []handler.OpenAPISecurityScheme{},
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite/{id}", handler.New(provider.authZ.AdminAccess(provider.userHandler.DeleteInvite), handler.OpenAPIDef{
-		ID:                  "DeleteInvite",
-		Tags:                []string{"users"},
-		Summary:             "Delete invite",
-		Description:         "This endpoint deletes an invite by id",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite", handler.New(provider.authZ.AdminAccess(provider.userHandler.ListInvite), handler.OpenAPIDef{
-		ID:                  "ListInvite",
-		Tags:                []string{"users"},
-		Summary:             "List invites",
-		Description:         "This endpoint lists all invites",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            make([]*types.Invite, 0),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleAdmin),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v1/invite/accept", handler.New(provider.authZ.OpenAccess(provider.userHandler.AcceptInvite), handler.OpenAPIDef{
-		ID:                  "AcceptInvite",
-		Tags:                []string{"users"},
-		Summary:             "Accept invite",
-		Description:         "This endpoint accepts an invite by token",
-		Request:             new(types.PostableAcceptInvite),
-		RequestContentType:  "application/json",
-		Response:            new(types.User),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusCreated,
-		ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-		Deprecated:          false,
-		SecuritySchemes:     []handler.OpenAPISecurityScheme{},
-	})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v1/pats", handler.New(provider.authZ.AdminAccess(provider.userHandler.CreateAPIKey), handler.OpenAPIDef{
 		ID:                  "CreateAPIKey",
 		Tags:                []string{"users"},

pkg/modules/user/impluser/handler.go

@@ -27,25 +27,6 @@ func NewHandler(module root.Module, getter root.Getter) root.Handler {
 	return &handler{module: module, getter: getter}
 }
 
-func (h *handler) AcceptInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	req := new(types.PostableAcceptInvite)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	user, err := h.module.AcceptInvite(ctx, req.InviteToken, req.Password)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusCreated, user)
-}
-
 func (h *handler) CreateInvite(rw http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()
@@ -104,59 +85,6 @@ func (h *handler) CreateBulkInvite(rw http.ResponseWriter, r *http.Request) {
 	render.Success(rw, http.StatusCreated, nil)
 }
 
-func (h *handler) GetInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	token := mux.Vars(r)["token"]
-	invite, err := h.module.GetInviteByToken(ctx, token)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, invite)
-}
-
-func (h *handler) ListInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	invites, err := h.module.ListInvite(ctx, claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusOK, invites)
-}
-
-func (h *handler) DeleteInvite(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	id := mux.Vars(r)["id"]
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	if err := h.module.DeleteUser(ctx, valuer.MustNewUUID(claims.OrgID), id, claims.UserID); err != nil {
-		render.Error(w, err)
-		return
-	}
-
-	render.Success(w, http.StatusNoContent, nil)
-}
-
 func (h *handler) GetUser(w http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()
@@ -213,9 +141,6 @@ func (h *handler) ListUsers(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// temp code - show only active users
-	users = slices.DeleteFunc(users, func(user *types.User) bool { return user.Status != types.UserStatusActive })
-
 	render.Success(w, http.StatusOK, users)
 }
 

pkg/modules/user/impluser/module.go

@@ -49,54 +49,6 @@ func NewModule(store types.UserStore, tokenizer tokenizer.Tokenizer, emailing em
 	}
 }
 
-func (m *Module) AcceptInvite(ctx context.Context, token string, password string) (*types.User, error) {
-	// get the user by reset password token
-	user, err := m.store.GetUserByResetPasswordToken(ctx, token)
-	if err != nil {
-		return nil, err
-	}
-
-	// update the password and delete the token
-	err = m.UpdatePasswordByResetPasswordToken(ctx, token, password)
-	if err != nil {
-		return nil, err
-	}
-
-	// query the user again
-	user, err = m.store.GetByOrgIDAndID(ctx, user.OrgID, user.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return user, nil
-}
-
-func (m *Module) GetInviteByToken(ctx context.Context, token string) (*types.Invite, error) {
-	// get the user
-	user, err := m.store.GetUserByResetPasswordToken(ctx, token)
-	if err != nil {
-		return nil, err
-	}
-
-	// create a dummy invite obj for backward compatibility
-	invite := &types.Invite{
-		Identifiable: types.Identifiable{
-			ID: user.ID,
-		},
-		Name:  user.DisplayName,
-		Email: user.Email,
-		Token: token,
-		Role:  user.Role,
-		OrgID: user.OrgID,
-		TimeAuditable: types.TimeAuditable{
-			CreatedAt: user.CreatedAt,
-			UpdatedAt: user.UpdatedAt,
-		},
-	}
-
-	return invite, nil
-}
-
 // CreateBulk implements invite.Module.
 func (m *Module) CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, bulkInvites *types.PostableBulkInviteRequest) ([]*types.Invite, error) {
 	creator, err := m.store.GetUser(ctx, userID)
@@ -218,46 +170,6 @@ func (m *Module) CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID
 	return invites, nil
 }
 
-func (m *Module) ListInvite(ctx context.Context, orgID string) ([]*types.Invite, error) {
-	// find all the users with pending_invite status
-	users, err := m.store.ListUsersByOrgID(ctx, valuer.MustNewUUID(orgID))
-	if err != nil {
-		return nil, err
-	}
-
-	pendingUsers := slices.DeleteFunc(users, func(user *types.User) bool { return user.Status != types.UserStatusPendingInvite })
-
-	var invites []*types.Invite
-
-	for _, pUser := range pendingUsers {
-		// get the reset password token
-		resetPasswordToken, err := m.GetOrCreateResetPasswordToken(ctx, pUser.ID)
-		if err != nil {
-			return nil, err
-		}
-
-		// create a dummy invite obj for backward compatibility
-		invite := &types.Invite{
-			Identifiable: types.Identifiable{
-				ID: pUser.ID,
-			},
-			Name:  pUser.DisplayName,
-			Email: pUser.Email,
-			Token: resetPasswordToken.Token,
-			Role:  pUser.Role,
-			OrgID: pUser.OrgID,
-			TimeAuditable: types.TimeAuditable{
-				CreatedAt: pUser.CreatedAt,
-				UpdatedAt: pUser.UpdatedAt, // dummy
-			},
-		}
-
-		invites = append(invites, invite)
-	}
-
-	return invites, nil
-}
-
 func (module *Module) CreateUser(ctx context.Context, input *types.User, opts ...root.CreateUserOption) error {
 	createUserOpts := root.NewCreateUserOptions(opts...)
 
@@ -304,10 +216,6 @@ func (m *Module) UpdateUser(ctx context.Context, orgID valuer.UUID, id string, u
 		return nil, errors.WithAdditionalf(err, "cannot update deleted user")
 	}
 
-	if err := existingUser.ErrIfPending(); err != nil {
-		return nil, errors.WithAdditionalf(err, "cannot update pending user")
-	}
-
 	requestor, err := m.store.GetUser(ctx, valuer.MustNewUUID(updatedBy))
 	if err != nil {
 		return nil, err

pkg/modules/user/user.go

@@ -41,9 +41,6 @@ type Module interface {
 
 	// invite
 	CreateBulkInvite(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, bulkInvites *types.PostableBulkInviteRequest) ([]*types.Invite, error)
-	ListInvite(ctx context.Context, orgID string) ([]*types.Invite, error)
-	AcceptInvite(ctx context.Context, token string, password string) (*types.User, error)
-	GetInviteByToken(ctx context.Context, token string) (*types.Invite, error)
 
 	// API KEY
 	CreateAPIKey(ctx context.Context, apiKey *types.StorableAPIKey) error
@@ -89,10 +86,6 @@ type Getter interface {
 type Handler interface {
 	// invite
 	CreateInvite(http.ResponseWriter, *http.Request)
-	AcceptInvite(http.ResponseWriter, *http.Request)
-	GetInvite(http.ResponseWriter, *http.Request) // public function
-	ListInvite(http.ResponseWriter, *http.Request)
-	DeleteInvite(http.ResponseWriter, *http.Request)
 	CreateBulkInvite(http.ResponseWriter, *http.Request)
 
 	ListUsers(http.ResponseWriter, *http.Request)

pkg/query-service/agentConf/db.go

@@ -115,6 +115,7 @@ func (r *Repo) GetLatestVersion(
 func (r *Repo) insertConfig(
 	ctx context.Context, orgId valuer.UUID, userId valuer.UUID, c *opamptypes.AgentConfigVersion, elements []string,
 ) error {
+
 	if c.ElementType.StringValue() == "" {
 		return errors.NewInvalidInputf(CodeElementTypeRequired, "element type is required for creating agent config version")
 	}
@@ -228,25 +229,6 @@ func (r *Repo) updateDeployStatus(ctx context.Context,
 	return nil
 }
 
-// GetDeployStatusByHash returns the DeployStatus for the given config hash
-// (stored with orgId prefix). Returns DeployStatusUnknown when no matching row exists.
-func (r *Repo) GetDeployStatusByHash(ctx context.Context, orgId valuer.UUID, configHash string) (opamptypes.DeployStatus, error) {
-	var version opamptypes.AgentConfigVersion
-	err := r.store.BunDB().NewSelect().
-		Model(&version).
-		ColumnExpr("deploy_status").
-		Where("hash = ?", configHash).
-		Where("org_id = ?", orgId).
-		Scan(ctx)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return opamptypes.DeployStatusUnknown, nil
-		}
-		return opamptypes.DeployStatusUnknown, errors.WrapInternalf(err, errors.CodeInternal, "failed to query deploy status by hash")
-	}
-	return version.DeployStatus, nil
-}
-
 func (r *Repo) updateDeployStatusByHash(
 	ctx context.Context, orgId valuer.UUID, confighash string, status string, result string,
 ) error {

pkg/query-service/agentConf/manager.go

@@ -180,12 +180,6 @@ func (m *Manager) ReportConfigDeploymentStatus(
 	}
 }
 
-// Implements model.AgentConfigProvider
-func (m *Manager) GetDeployStatusByHash(ctx context.Context, orgId valuer.UUID, configHash string) (opamptypes.DeployStatus, error) {
-	return m.Repo.GetDeployStatusByHash(ctx, orgId, configHash)
-}
-
-
 func GetLatestVersion(
 	ctx context.Context, orgId valuer.UUID, elementType opamptypes.ElementType,
 ) (*opamptypes.AgentConfigVersion, error) {

pkg/query-service/app/clickhouseReader/reader.go

@@ -3945,67 +3945,53 @@ func (r *ClickHouseReader) GetLogAttributeKeys(ctx context.Context, req *v3.Filt
 		instrumentationtypes.CodeNamespace:    "clickhouse-reader",
 		instrumentationtypes.CodeFunctionName: "GetLogAttributeKeys",
 	})
+	var query string
+	var err error
+	var rows driver.Rows
 	var response v3.FilterAttributeKeyResponse
 
-	attributeKeysTable := r.logsDB + "." + r.logsAttributeKeys
-	resourceAttrKeysTable := r.logsDB + "." + r.logsResourceKeys
-
-	var tagTypes []string
-	var tables []string
-	switch req.TagType {
-	case v3.TagTypeTag:
-		tables, tagTypes = []string{attributeKeysTable}, []string{"tag"}
-	case v3.TagTypeResource:
-		tables, tagTypes = []string{resourceAttrKeysTable}, []string{"resource"}
-	case "":
-		tables, tagTypes = []string{attributeKeysTable, resourceAttrKeysTable}, []string{"tag", "resource"}
-	default:
-		return nil, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "unsupported tag type: %s", req.TagType)
+	tagTypeFilter := `tag_type != 'logfield'`
+	if req.TagType != "" {
+		tagTypeFilter = fmt.Sprintf(`tag_type != 'logfield' and tag_type = '%s'`, req.TagType)
 	}
 
+	if len(req.SearchText) != 0 {
+		query = fmt.Sprintf("select distinct tag_key, tag_type, tag_data_type from  %s.%s where %s and tag_key ILIKE $1 limit $2", r.logsDB, r.logsTagAttributeTableV2, tagTypeFilter)
+		rows, err = r.db.Query(ctx, query, fmt.Sprintf("%%%s%%", req.SearchText), req.Limit)
+	} else {
+		query = fmt.Sprintf("select distinct tag_key, tag_type, tag_data_type from %s.%s where %s limit $1", r.logsDB, r.logsTagAttributeTableV2, tagTypeFilter)
+		rows, err = r.db.Query(ctx, query, req.Limit)
+	}
+
+	if err != nil {
+		r.logger.Error("Error while executing query", "error", err)
+		return nil, fmt.Errorf("error while executing query: %s", err.Error())
+	}
+	defer rows.Close()
+
 	statements := []model.ShowCreateTableStatement{}
-	stmtQuery := fmt.Sprintf("SHOW CREATE TABLE %s.%s", r.logsDB, r.logsLocalTableName)
-	if err := r.db.Select(ctx, &statements, stmtQuery); err != nil {
-		return nil, errorsV2.Wrapf(err, errorsV2.TypeInternal, errorsV2.CodeInternal, "error while fetching logs schema")
+	query = fmt.Sprintf("SHOW CREATE TABLE %s.%s", r.logsDB, r.logsLocalTableName)
+	err = r.db.Select(ctx, &statements, query)
+	if err != nil {
+		return nil, fmt.Errorf("error while fetching logs schema: %s", err.Error())
 	}
 
-	for i, table := range tables {
-		tagType := tagTypes[i]
-		var query string
-		if len(req.SearchText) != 0 {
-			query = fmt.Sprintf("select distinct name, lower(datatype) from %s where name ILIKE $1 limit $2", table)
-		} else {
-			query = fmt.Sprintf("select distinct name, lower(datatype) from %s limit $1", table)
+	var attributeKey string
+	var attributeDataType string
+	var tagType string
+	for rows.Next() {
+		if err := rows.Scan(&attributeKey, &tagType, &attributeDataType); err != nil {
+			return nil, fmt.Errorf("error while scanning rows: %s", err.Error())
 		}
 
-		var rows driver.Rows
-		var err error
-		if len(req.SearchText) != 0 {
-			rows, err = r.db.Query(ctx, query, fmt.Sprintf("%%%s%%", req.SearchText), req.Limit)
-		} else {
-			rows, err = r.db.Query(ctx, query, req.Limit)
-		}
-		if err != nil {
-			return nil, errorsV2.Wrapf(err, errorsV2.TypeInternal, errorsV2.CodeInternal, "error while executing query")
+		key := v3.AttributeKey{
+			Key:      attributeKey,
+			DataType: v3.AttributeKeyDataType(attributeDataType),
+			Type:     v3.AttributeKeyType(tagType),
+			IsColumn: isColumn(statements[0].Statement, tagType, attributeKey, attributeDataType),
 		}
 
-		for rows.Next() {
-			var keyName string
-			var datatype string
-			if err := rows.Scan(&keyName, &datatype); err != nil {
-				rows.Close()
-				return nil, errorsV2.Wrapf(err, errorsV2.TypeInternal, errorsV2.CodeInternal, "error while scanning rows")
-			}
-
-			key := v3.AttributeKey{
-				Key:      keyName,
-				DataType: v3.AttributeKeyDataType(datatype),
-				Type:     v3.AttributeKeyType(tagType),
-				IsColumn: isColumn(statements[0].Statement, tagType, keyName, datatype),
-			}
-			response.AttributeKeys = append(response.AttributeKeys, key)
-		}
-		rows.Close()
+		response.AttributeKeys = append(response.AttributeKeys, key)
 	}
 
 	// add other attributes only when the tagType is not specified

pkg/query-service/app/cloudintegrations/accountsRepo.go

@@ -177,7 +177,7 @@ func (r *cloudProviderAccountsSQLRepository) upsert(
 	onConflictClause := ""
 	if len(onConflictSetStmts) > 0 {
 		onConflictClause = fmt.Sprintf(
-			"conflict(id) do update SET\n%s",
+			"conflict(id, provider, org_id) do update SET\n%s",
 			strings.Join(onConflictSetStmts, ",\n"),
 		)
 	}
@@ -202,8 +202,6 @@ func (r *cloudProviderAccountsSQLRepository) upsert(
 		Exec(ctx)
 
 	if dbErr != nil {
-		// for now returning internal error even if there is a conflict,
-		// will be handled better in the future iteration
 		return nil, model.InternalError(fmt.Errorf(
 			"could not upsert cloud account record: %w", dbErr,
 		))

pkg/query-service/app/opamp/config_provider.go

@@ -1,8 +1,6 @@
 package opamp
 
-import (
-	"github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
-)
+import "github.com/SigNoz/signoz/pkg/query-service/app/opamp/model"
 
 // Interface for a source of otel collector config recommendations.
 type AgentConfigProvider interface {

pkg/query-service/app/opamp/mocks.go

@@ -5,7 +5,6 @@ import (
 	"log"
 	"net"
 
-	"github.com/SigNoz/signoz/pkg/types/opamptypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/google/uuid"
 	"github.com/knadh/koanf"
@@ -128,11 +127,6 @@ func (ta *MockAgentConfigProvider) HasReportedDeploymentStatus(orgID valuer.UUID
 	return exists
 }
 
-// AgentConfigProvider interface
-func (ta *MockAgentConfigProvider) GetDeployStatusByHash(_ context.Context, _ valuer.UUID, _ string) (opamptypes.DeployStatus, error) {
-	return opamptypes.DeployStatusUnknown, nil
-}
-
 // AgentConfigProvider interface
 func (ta *MockAgentConfigProvider) SubscribeToConfigUpdates(callback func()) func() {
 	subscriberId := uuid.NewString()

pkg/query-service/app/opamp/model/agent.go

@@ -111,99 +111,90 @@ func ExtractLbFlag(agentDescr *protobufs.AgentDescription) bool {
 	return false
 }
 
-// agentDescriptionChanged returns true when the agent sends updated properties
-// (e.g. capability flag, version) mid-connection, signalling the server to
-// recompute and push a new RemoteConfig.
-//
-// On reconnect this always returns false: handleFirstStatus pre-copies
-// AgentDescription into agent.Status so no diff is detected, avoiding a
-// redundant config recompute.
-func (agent *Agent) agentDescriptionChanged(newStatus *protobufs.AgentToServer) bool {
-	// nil AgentDescription means no change per OpAMP protocol.
-	if newStatus.AgentDescription == nil {
-		return false
+func (agent *Agent) updateAgentDescription(newStatus *protobufs.AgentToServer) (agentDescrChanged bool) {
+	prevStatus := agent.Status
+
+	if agent.Status == nil {
+		// First time this Agent reports a status, remember it.
+		agent.Status = newStatus
+		agentDescrChanged = true
+	} else {
+		// Not a new Agent. Update the Status.
+		agent.Status.SequenceNum = newStatus.SequenceNum
+
+		// Check what's changed in the AgentDescription.
+		if newStatus.AgentDescription != nil {
+			// If the AgentDescription field is set it means the Agent tells us
+			// something is changed in the field since the last status report
+			// (or this is the first report).
+			// Make full comparison of previous and new descriptions to see if it
+			// really is different.
+			if prevStatus != nil && proto.Equal(prevStatus.AgentDescription, newStatus.AgentDescription) {
+				// Agent description didn't change.
+				agentDescrChanged = false
+			} else {
+				// Yes, the description is different, update it.
+				agent.Status.AgentDescription = newStatus.AgentDescription
+				agentDescrChanged = true
+			}
+		} else {
+			// AgentDescription field is not set, which means description didn't change.
+			agentDescrChanged = false
+		}
+
+		// Update remote config status if it is included and is different from what we have.
+		if newStatus.RemoteConfigStatus != nil &&
+			!proto.Equal(agent.Status.RemoteConfigStatus, newStatus.RemoteConfigStatus) {
+			agent.Status.RemoteConfigStatus = newStatus.RemoteConfigStatus
+
+			// todo: need to address multiple agent scenario here
+			// for now, the first response will be sent back to the UI
+			if agent.Status.RemoteConfigStatus.Status == protobufs.RemoteConfigStatuses_RemoteConfigStatuses_APPLIED {
+				onConfigSuccess(agent.OrgID, agent.AgentID, string(agent.Status.RemoteConfigStatus.LastRemoteConfigHash))
+			}
+
+			if agent.Status.RemoteConfigStatus.Status == protobufs.RemoteConfigStatuses_RemoteConfigStatuses_FAILED {
+				onConfigFailure(agent.OrgID, agent.AgentID, string(agent.Status.RemoteConfigStatus.LastRemoteConfigHash), agent.Status.RemoteConfigStatus.ErrorMessage)
+			}
+		}
 	}
-	if proto.Equal(agent.Status.AgentDescription, newStatus.AgentDescription) {
-		return false
+
+	if agentDescrChanged {
+		agent.CanLB = ExtractLbFlag(newStatus.AgentDescription)
+	}
+
+	return agentDescrChanged
+}
+
+func (agent *Agent) updateHealth(newStatus *protobufs.AgentToServer) {
+	if newStatus.Health == nil {
+		return
+	}
+
+	agent.Status.Health = newStatus.Health
+
+	if agent.Status != nil && agent.Status.Health != nil && agent.Status.Health.Healthy {
+		agent.TimeAuditable.UpdatedAt = time.Unix(0, int64(agent.Status.Health.StartTimeUnixNano)).UTC()
 	}
-	agent.CanLB = ExtractLbFlag(newStatus.AgentDescription)
-	return true
 }
 
-// updateRemoteConfigStatus updates the stored RemoteConfigStatus and notifies
-// subscribers if the status has changed relative to what we have stored.
 func (agent *Agent) updateRemoteConfigStatus(newStatus *protobufs.AgentToServer) {
-	if newStatus.RemoteConfigStatus == nil ||
-		proto.Equal(agent.Status.RemoteConfigStatus, newStatus.RemoteConfigStatus) {
-		return
-	}
-
-	// todo: need to address multiple agent scenario here
-	// for now, the first response will be sent back to the UI
-	hash := string(newStatus.RemoteConfigStatus.LastRemoteConfigHash)
-	switch newStatus.RemoteConfigStatus.Status {
-	case protobufs.RemoteConfigStatuses_RemoteConfigStatuses_APPLIED:
-		onConfigSuccess(agent.OrgID, agent.AgentID, hash)
-	case protobufs.RemoteConfigStatuses_RemoteConfigStatuses_FAILED:
-		onConfigFailure(agent.OrgID, agent.AgentID, hash, newStatus.RemoteConfigStatus.ErrorMessage)
+	// Update remote config status if it is included and is different from what we have.
+	if newStatus.RemoteConfigStatus != nil {
+		agent.Status.RemoteConfigStatus = newStatus.RemoteConfigStatus
 	}
 }
 
-// handleFirstStatus initializes agent.Status on the first message received from
-// this agent instance. It is a no-op for all subsequent messages.
-func (agent *Agent) handleFirstStatus(newStatus *protobufs.AgentToServer, configProvider AgentConfigProvider) {
-	if agent.Status != nil {
-		return
+func (agent *Agent) updateStatusField(newStatus *protobufs.AgentToServer) (agentDescrChanged bool) {
+	if agent.Status == nil {
+		// First time this Agent reports a status, remember it.
+		agent.Status = newStatus
+		agentDescrChanged = true
 	}
 
-	// Initialize with a clean slate.
-	agent.Status = &protobufs.AgentToServer{
-		RemoteConfigStatus: &protobufs.RemoteConfigStatus{
-			Status: protobufs.RemoteConfigStatuses_RemoteConfigStatuses_UNSET,
-		},
-	}
-
-	if newStatus.RemoteConfigStatus == nil ||
-		newStatus.RemoteConfigStatus.Status == protobufs.RemoteConfigStatuses_RemoteConfigStatuses_UNSET {
-		// Agent just started fresh — no prior deployment to reconcile with the DB.
-		return
-	}
-
-	// Since the server's connection is restarted;
-	// copy the agent description; so no change is detected by agentDescriptionChanged
-	agent.Status.AgentDescription = newStatus.AgentDescription
-
-	// Server reconnected while the agent was already running.
-	// Reconcile deployment status with DB; DB is the source of truth.
-	// If DB says in_progress but agent now reports APPLIED/FAILED,
-	// updateRemoteConfigStatus will detect the transition and notify subscribers.
-	rawHash := string(newStatus.RemoteConfigStatus.LastRemoteConfigHash)
-	deployStatus, err := configProvider.GetDeployStatusByHash(context.Background(), agent.OrgID, agent.OrgID.String()+rawHash)
-	if err != nil {
-		return
-	}
-
-	agent.Status.RemoteConfigStatus.Status = opamptypes.DeployStatusToProtoStatus[deployStatus]
-
-	// If the deployment is still in-flight, rehydrate the subscriber so that
-	// updateRemoteConfigStatus can fire onConfigSuccess/onConfigFailure when
-	// the agent next reports a terminal status.
-	if deployStatus != opamptypes.Deployed && deployStatus != opamptypes.DeployFailed {
-		ListenToConfigUpdate(agent.OrgID, agent.AgentID, rawHash, configProvider.ReportConfigDeploymentStatus)
-	}
-}
-
-func (agent *Agent) updateStatusField(newStatus *protobufs.AgentToServer, configProvider AgentConfigProvider) bool {
-	agent.handleFirstStatus(newStatus, configProvider)
-	agentDescrChanged := agent.agentDescriptionChanged(newStatus)
-	// record healthy timestamp
-	if newStatus.Health != nil && newStatus.Health.Healthy {
-		agent.TimeAuditable.UpdatedAt = time.Unix(0, int64(newStatus.Health.StartTimeUnixNano)).UTC()
-	}
-	// notify subscribers first; this will update the status in the DB
+	agentDescrChanged = agent.updateAgentDescription(newStatus) || agentDescrChanged
 	agent.updateRemoteConfigStatus(newStatus)
-	// update local reference in last.
-	agent.Status = newStatus
+	agent.updateHealth(newStatus)
 	return agentDescrChanged
 }
 
@@ -246,7 +237,7 @@ func (agent *Agent) processStatusUpdate(
 	// current status is not up-to-date.
 	lostPreviousUpdate := (agent.Status == nil) || (agent.Status != nil && agent.Status.SequenceNum+1 != newStatus.SequenceNum)
 
-	agentDescrChanged := agent.updateStatusField(newStatus, configProvider)
+	agentDescrChanged := agent.updateStatusField(newStatus)
 
 	// Check if any fields were omitted in the status report.
 	effectiveConfigOmitted := newStatus.EffectiveConfig == nil &&

pkg/query-service/app/opamp/model/config.go

@@ -1,11 +1,6 @@
 package model
 
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/types/opamptypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
+import "github.com/SigNoz/signoz/pkg/valuer"
 
 // Interface for source of otel collector config recommendations.
 type AgentConfigProvider interface {
@@ -25,10 +20,4 @@ type AgentConfigProvider interface {
 		configId string,
 		err error,
 	)
-
-	// GetDeployStatusByHash returns the DeployStatus for the given config hash
-	// (with orgId prefix as stored in the DB). Returns DeployStatusUnknown when
-	// no matching row exists. Used by the agent's first-connect handler to
-	// determine whether the reported RemoteConfigStatus resolves a pending deployment.
-	GetDeployStatusByHash(ctx context.Context, orgId valuer.UUID, configHash string) (opamptypes.DeployStatus, error)
 }

pkg/query-service/app/opamp/model/coordinator.go

@@ -66,7 +66,6 @@ func ListenToConfigUpdate(orgId valuer.UUID, agentId string, hash string, ss OnC
 	defer coordinator.mutex.Unlock()
 
 	key := getSubscriberKey(orgId, hash)
-
 	if subs, ok := coordinator.subscribers[key]; ok {
 		subs = append(subs, ss)
 		coordinator.subscribers[key] = subs

pkg/query-service/constants/constants.go

@@ -28,9 +28,6 @@ const SpanSearchScopeRoot = "isroot"
 const SpanSearchScopeEntryPoint = "isentrypoint"
 const OrderBySpanCount = "span_count"
 
-// Deprecated: Use the new emailing service instead
-var InviteEmailTemplate = GetOrDefaultEnv("INVITE_EMAIL_TEMPLATE", "/root/templates/invitation_email.gotmpl")
-
 var MetricsExplorerClickhouseThreads = GetOrDefaultEnvInt("METRICS_EXPLORER_CLICKHOUSE_THREADS", 8)
 var UpdatedMetricsMetadataCachePrefix = GetOrDefaultEnv("METRICS_UPDATED_METADATA_CACHE_KEY", "UPDATED_METRICS_METADATA")
 

pkg/ruler/rulestore/sqlrulestore/maintenance.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
@@ -136,7 +135,7 @@ func (r *maintenance) DeletePlannedMaintenance(ctx context.Context, id valuer.UU
 		Where("id = ?", id.StringValue()).
 		Exec(ctx)
 	if err != nil {
-		return r.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "cannot delete planned maintenance because it is referenced by associated rules, remove the rules from the planned maintenance first")
+		return err
 	}
 
 	return nil

pkg/ruler/rulestore/sqlrulestore/rule.go

@@ -6,7 +6,6 @@ import (
 	"log/slog"
 	"slices"
 
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
@@ -76,7 +75,7 @@ func (r *rule) DeleteRule(ctx context.Context, id valuer.UUID, cb func(context.C
 			Where("id = ?", id.StringValue()).
 			Exec(ctx)
 		if err != nil {
-			return r.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "cannot delete rule because it is referenced by a planned maintenance, remove the rule from the planned maintenance first")
+			return err
 		}
 
 		return cb(ctx)

pkg/signoz/provider.go

@@ -175,8 +175,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewMigrateRulesV4ToV5Factory(sqlstore, telemetryStore),
 		sqlmigration.NewAddStatusUserFactory(sqlstore, sqlschema),
 		sqlmigration.NewDeprecateUserInviteFactory(sqlstore, sqlschema),
-		sqlmigration.NewUpdateCloudIntegrationUniqueIndexFactory(sqlstore, sqlschema),
-		sqlmigration.NewUpdatePlannedMaintenanceRuleFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/sqlmigration/069_update_cloud_integration_index.go

@@ -1,255 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type updateCloudIntegrationUniqueIndex struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewUpdateCloudIntegrationUniqueIndexFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(
-		factory.MustNewName("update_cloud_integration_index"),
-		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-			return &updateCloudIntegrationUniqueIndex{
-				sqlstore:  sqlstore,
-				sqlschema: sqlschema,
-			}, nil
-		},
-	)
-}
-
-func (migration *updateCloudIntegrationUniqueIndex) Register(migrations *migrate.Migrations) error {
-	if err := migrations.Register(migration.Up, migration.Down); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-type cloudIntegrationRow struct {
-	bun.BaseModel `bun:"table:cloud_integration"`
-
-	ID        string    `bun:"id"`
-	AccountID string    `bun:"account_id"`
-	Provider  string    `bun:"provider"`
-	OrgID     string    `bun:"org_id"`
-	Config    string    `bun:"config"`
-	UpdatedAt time.Time `bun:"updated_at"`
-}
-
-type cloudIntegrationAccountConfig struct {
-	Regions []string `json:"regions"`
-}
-
-// duplicateGroup holds the keeper (first element) and losers (rest) for a duplicate (account_id, provider, org_id) group.
-type duplicateGroup struct {
-	keeper *cloudIntegrationRow
-	losers []*cloudIntegrationRow
-}
-
-func (migration *updateCloudIntegrationUniqueIndex) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	sqls := [][]byte{}
-
-	// Step 1: Drop the wrong index on (id, provider, org_id)
-	dropSqls := migration.sqlschema.Operator().DropIndex(
-		(&sqlschema.UniqueIndex{
-			TableName:   "cloud_integration",
-			ColumnNames: []sqlschema.ColumnName{"id", "provider", "org_id"},
-		}).Named("unique_cloud_integration"),
-	)
-	sqls = append(sqls, dropSqls...)
-
-	// Step 2: Normalize empty-string account_id to NULL
-	// Older table structure could store "" instead of NULL for unconnected accounts.
-	// Empty strings would violate the partial unique index since '' = '' (unlike NULL != NULL).
-	_, err = tx.NewUpdate().
-		TableExpr("cloud_integration").
-		Set("account_id = NULL").
-		Where("account_id = ''").
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Step 3: Fetch all active rows with non-null account_id, ordered for grouping
-	var activeRows []*cloudIntegrationRow
-	err = tx.NewSelect().
-		Model(&activeRows).
-		Where("removed_at IS NULL").
-		Where("account_id IS NOT NULL").
-		OrderExpr("account_id, provider, org_id, updated_at DESC").
-		Scan(ctx)
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return err
-	}
-
-	// Group by (account_id, provider, org_id)
-	groups := groupCloudIntegrationRows(activeRows)
-
-	now := time.Now()
-	var loserIDs []string
-
-	for _, group := range groups {
-		if len(group.losers) == 0 {
-			continue
-		}
-
-		// Step 4: Merge config from losers into keeper
-		if err = mergeCloudIntegrationConfigs(ctx, tx, group); err != nil {
-			return err
-		}
-
-		// Step 5: Reassign non-conflicting cloud_integration_service rows to keeper
-		for _, loser := range group.losers {
-			_, err = tx.NewUpdate().
-				TableExpr("cloud_integration_service").
-				Set("cloud_integration_id = ?", group.keeper.ID).
-				Where("cloud_integration_id = ?", loser.ID).
-				Where("type NOT IN (?)",
-					tx.NewSelect().
-						TableExpr("cloud_integration_service").
-						Column("type").
-						Where("cloud_integration_id = ?", group.keeper.ID),
-				).
-				Exec(ctx)
-			if err != nil {
-				return err
-			}
-
-			loserIDs = append(loserIDs, loser.ID)
-		}
-	}
-
-	// Step 6: Soft-delete all loser rows
-	if len(loserIDs) > 0 {
-		_, err = tx.NewUpdate().
-			TableExpr("cloud_integration").
-			Set("removed_at = ?", now).
-			Set("updated_at = ?", now).
-			Where("id IN (?)", bun.In(loserIDs)).
-			Exec(ctx)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Step 7: Create the correct partial unique index on (account_id, provider, org_id) WHERE removed_at IS NULL
-	createSqls := migration.sqlschema.Operator().CreateIndex(
-		&sqlschema.PartialUniqueIndex{
-			TableName:   "cloud_integration",
-			ColumnNames: []sqlschema.ColumnName{"account_id", "provider", "org_id"},
-			Where:       "removed_at IS NULL",
-		},
-	)
-	sqls = append(sqls, createSqls...)
-
-	for _, sql := range sqls {
-		if _, err = tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *updateCloudIntegrationUniqueIndex) Down(ctx context.Context, db *bun.DB) error {
-	return nil
-}
-
-// groupCloudIntegrationRows groups rows by (account_id, provider, org_id).
-// Rows must be pre-sorted by account_id, provider, org_id, updated_at DESC
-// so the first row in each group is the keeper (most recently updated).
-func groupCloudIntegrationRows(rows []*cloudIntegrationRow) []duplicateGroup {
-	if len(rows) == 0 {
-		return nil
-	}
-
-	var groups []duplicateGroup
-	var current duplicateGroup
-	current.keeper = rows[0]
-
-	for i := 1; i < len(rows); i++ {
-		row := rows[i]
-		if row.AccountID == current.keeper.AccountID &&
-			row.Provider == current.keeper.Provider &&
-			row.OrgID == current.keeper.OrgID {
-			current.losers = append(current.losers, row)
-		} else {
-			groups = append(groups, current)
-			current = duplicateGroup{keeper: row}
-		}
-	}
-	groups = append(groups, current)
-
-	return groups
-}
-
-// mergeCloudIntegrationConfigs unions the EnabledRegions from all rows in the group into the keeper's config and updates
-func mergeCloudIntegrationConfigs(ctx context.Context, tx bun.Tx, group duplicateGroup) error {
-	regionSet := make(map[string]struct{})
-
-	// Parse keeper's config
-	parseRegions(group.keeper.Config, regionSet)
-
-	// Parse each loser's config
-	for _, loser := range group.losers {
-		parseRegions(loser.Config, regionSet)
-	}
-
-	// Build merged config
-	mergedRegions := make([]string, 0, len(regionSet))
-	for region := range regionSet {
-		mergedRegions = append(mergedRegions, region)
-	}
-
-	merged := cloudIntegrationAccountConfig{Regions: mergedRegions}
-	mergedJSON, err := json.Marshal(merged)
-	if err != nil {
-		return err
-	}
-
-	// Update keeper's config
-	_, err = tx.NewUpdate().
-		TableExpr("cloud_integration").
-		Set("config = ?", string(mergedJSON)).
-		Where("id = ?", group.keeper.ID).
-		Exec(ctx)
-	return err
-}
-
-// parseRegions unmarshals a config JSON string and adds its regions to the set.
-func parseRegions(configJSON string, regionSet map[string]struct{}) {
-	if configJSON == "" {
-		return
-	}
-
-	var config cloudIntegrationAccountConfig
-	if err := json.Unmarshal([]byte(configJSON), &config); err != nil {
-		return
-	}
-
-	for _, region := range config.Regions {
-		regionSet[region] = struct{}{}
-	}
-}

pkg/sqlmigration/070_update_planned_maintenance_rule.go

@@ -1,132 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type updatePlannedMaintenanceRule struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-type plannedMaintenanceRuleRow struct {
-	bun.BaseModel `bun:"table:planned_maintenance_rule"`
-
-	ID                   string `bun:"id"`
-	PlannedMaintenanceID string `bun:"planned_maintenance_id"`
-	RuleID               string `bun:"rule_id"`
-}
-
-func NewUpdatePlannedMaintenanceRuleFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(
-		factory.MustNewName("update_planned_maintenance_rule"),
-		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-			return &updatePlannedMaintenanceRule{
-				sqlstore:  sqlstore,
-				sqlschema: sqlschema,
-			}, nil
-		},
-	)
-}
-
-func (migration *updatePlannedMaintenanceRule) Register(migrations *migrate.Migrations) error {
-	if err := migrations.Register(migration.Up, migration.Down); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (migration *updatePlannedMaintenanceRule) Up(ctx context.Context, db *bun.DB) error {
-	table, _, err := migration.sqlschema.GetTable(ctx, sqlschema.TableName("planned_maintenance_rule"))
-	if err != nil {
-		return err
-	}
-
-	if err := migration.sqlschema.ToggleFKEnforcement(ctx, db, false); err != nil {
-		return err
-	}
-
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	// Read all existing rows
-	var rows []*plannedMaintenanceRuleRow
-	err = tx.NewSelect().Model(&rows).Scan(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Drop the existing table
-	dropTableSQLs := migration.sqlschema.Operator().DropTable(table)
-	for _, sql := range dropTableSQLs {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	// Create the table fresh without CASCADE constraints
-	newTable := &sqlschema.Table{
-		Name: sqlschema.TableName("planned_maintenance_rule"),
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "planned_maintenance_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "rule_id", DataType: sqlschema.DataTypeText, Nullable: false},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{
-			ColumnNames: []sqlschema.ColumnName{"id"},
-		},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: "planned_maintenance_id",
-				ReferencedTableName:   "planned_maintenance",
-				ReferencedColumnName:  "id",
-			},
-			{
-				ReferencingColumnName: "rule_id",
-				ReferencedTableName:   "rule",
-				ReferencedColumnName:  "id",
-			},
-		},
-	}
-
-	createTableSQLs := migration.sqlschema.Operator().CreateTable(newTable)
-	for _, sql := range createTableSQLs {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	// Re-insert the data
-	if len(rows) > 0 {
-		_, err = tx.NewInsert().Model(&rows).Exec(ctx)
-		if err != nil {
-			return err
-		}
-	}
-
-	if err := tx.Commit(); err != nil {
-		return err
-	}
-
-	if err := migration.sqlschema.ToggleFKEnforcement(ctx, db, true); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (migration *updatePlannedMaintenanceRule) Down(ctx context.Context, db *bun.DB) error {
-	return nil
-}

pkg/sqlstore/sqlitesqlstore/provider.go

@@ -100,7 +100,7 @@ func (provider *provider) WrapNotFoundErrf(err error, code errors.Code, format s
 
 func (provider *provider) WrapAlreadyExistsErrf(err error, code errors.Code, format string, args ...any) error {
 	if sqlite3Err, ok := err.(*sqlite.Error); ok {
-		if sqlite3Err.Code() == sqlite3.SQLITE_CONSTRAINT_UNIQUE || sqlite3Err.Code() == sqlite3.SQLITE_CONSTRAINT_PRIMARYKEY || sqlite3Err.Code() == sqlite3.SQLITE_CONSTRAINT_FOREIGNKEY {
+		if sqlite3Err.Code() == sqlite3.SQLITE_CONSTRAINT_UNIQUE || sqlite3Err.Code() == sqlite3.SQLITE_CONSTRAINT_PRIMARYKEY {
 			return errors.Wrapf(err, errors.TypeAlreadyExists, code, format, args...)
 		}
 	}

pkg/types/invite.go

@@ -30,22 +30,6 @@ type Invite struct {
 	InviteLink string `bun:"-" json:"inviteLink"`
 }
 
-type InviteEmailData struct {
-	CustomerName string
-	InviterName  string
-	InviterEmail string
-	Link         string
-}
-
-type PostableAcceptInvite struct {
-	DisplayName string `json:"displayName"`
-	InviteToken string `json:"token"`
-	Password    string `json:"password"`
-
-	// reference URL to track where the register request is coming from
-	SourceURL string `json:"sourceUrl"`
-}
-
 type PostableInvite struct {
 	Name            string       `json:"name"`
 	Email           valuer.Email `json:"email"`
@@ -79,10 +63,6 @@ func (request *PostableBulkInviteRequest) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-type GettableCreateInviteResponse struct {
-	InviteToken string `json:"token"`
-}
-
 func NewInvite(name string, role Role, orgID valuer.UUID, email valuer.Email) (*Invite, error) {
 	invite := &Invite{
 		Identifiable: Identifiable{
@@ -101,23 +81,3 @@ func NewInvite(name string, role Role, orgID valuer.UUID, email valuer.Email) (*
 
 	return invite, nil
 }
-
-func (request *PostableAcceptInvite) UnmarshalJSON(data []byte) error {
-	type Alias PostableAcceptInvite
-
-	var temp Alias
-	if err := json.Unmarshal(data, &temp); err != nil {
-		return err
-	}
-
-	if temp.InviteToken == "" {
-		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "invite token is required")
-	}
-
-	if !IsPasswordValid(temp.Password) {
-		return ErrInvalidPassword
-	}
-
-	*request = PostableAcceptInvite(temp)
-	return nil
-}

pkg/types/opamptypes/agent.go

@@ -6,7 +6,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/open-telemetry/opamp-go/protobufs"
 	"github.com/uptrace/bun"
 )
 
@@ -18,15 +17,6 @@ const (
 	AgentStatusDisconnected
 )
 
-var DeployStatusToProtoStatus = map[DeployStatus]protobufs.RemoteConfigStatuses{
-	PendingDeploy:       protobufs.RemoteConfigStatuses_RemoteConfigStatuses_UNSET,
-	Deploying:           protobufs.RemoteConfigStatuses_RemoteConfigStatuses_APPLYING,
-	Deployed:            protobufs.RemoteConfigStatuses_RemoteConfigStatuses_APPLIED,
-	DeployInitiated:     protobufs.RemoteConfigStatuses_RemoteConfigStatuses_APPLYING,
-	DeployFailed:        protobufs.RemoteConfigStatuses_RemoteConfigStatuses_FAILED,
-	DeployStatusUnknown: protobufs.RemoteConfigStatuses_RemoteConfigStatuses_UNSET,
-}
-
 type StorableAgent struct {
 	bun.BaseModel `bun:"table:agent"`
 
@@ -40,6 +30,16 @@ type StorableAgent struct {
 	Config       string      `bun:"config,type:text,notnull"`
 }
 
+func NewStorableAgent(store sqlstore.SQLStore, orgID valuer.UUID, agentID string, status AgentStatus) StorableAgent {
+	return StorableAgent{
+		OrgID:         orgID,
+		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
+		AgentID:       agentID,
+		TimeAuditable: types.TimeAuditable{CreatedAt: time.Now(), UpdatedAt: time.Now()},
+		Status:        status,
+	}
+}
+
 type ElementType struct{ valuer.String }
 
 var (
@@ -49,6 +49,24 @@ var (
 	ElementTypeLbExporter    = ElementType{valuer.NewString("lb_exporter")}
 )
 
+// NewElementType creates a new ElementType from a string value.
+// Returns the corresponding ElementType constant if the string matches,
+// otherwise returns an empty ElementType.
+func NewElementType(value string) ElementType {
+	switch valuer.NewString(value) {
+	case ElementTypeSamplingRules.String:
+		return ElementTypeSamplingRules
+	case ElementTypeDropRules.String:
+		return ElementTypeDropRules
+	case ElementTypeLogPipelines.String:
+		return ElementTypeLogPipelines
+	case ElementTypeLbExporter.String:
+		return ElementTypeLbExporter
+	default:
+		return ElementType{valuer.NewString("")}
+	}
+}
+
 type DeployStatus struct{ valuer.String }
 
 var (
@@ -80,26 +98,6 @@ type AgentConfigVersion struct {
 	Config         string       `json:"config" bun:"config,type:text"`
 }
 
-type AgentConfigElement struct {
-	bun.BaseModel `bun:"table:agent_config_element"`
-
-	types.Identifiable
-	types.TimeAuditable
-	ElementID   string      `bun:"element_id,type:text,notnull,unique:element_type_version_idx"`
-	ElementType string      `bun:"element_type,type:text,notnull,unique:element_type_version_idx"`
-	VersionID   valuer.UUID `bun:"version_id,type:text,notnull,unique:element_type_version_idx"`
-}
-
-func NewStorableAgent(store sqlstore.SQLStore, orgID valuer.UUID, agentID string, status AgentStatus) StorableAgent {
-	return StorableAgent{
-		OrgID:         orgID,
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		AgentID:       agentID,
-		TimeAuditable: types.TimeAuditable{CreatedAt: time.Now(), UpdatedAt: time.Now()},
-		Status:        status,
-	}
-}
-
 func NewAgentConfigVersion(orgId valuer.UUID, userId valuer.UUID, elementType ElementType) *AgentConfigVersion {
 	return &AgentConfigVersion{
 		TimeAuditable: types.TimeAuditable{
@@ -120,20 +118,12 @@ func (a *AgentConfigVersion) IncrementVersion(lastVersion int) {
 	a.Version = lastVersion + 1
 }
 
-// NewElementType creates a new ElementType from a string value.
-// Returns the corresponding ElementType constant if the string matches,
-// otherwise returns an empty ElementType.
-func NewElementType(value string) ElementType {
-	switch valuer.NewString(value) {
-	case ElementTypeSamplingRules.String:
-		return ElementTypeSamplingRules
-	case ElementTypeDropRules.String:
-		return ElementTypeDropRules
-	case ElementTypeLogPipelines.String:
-		return ElementTypeLogPipelines
-	case ElementTypeLbExporter.String:
-		return ElementTypeLbExporter
-	default:
-		return ElementType{valuer.NewString("")}
-	}
+type AgentConfigElement struct {
+	bun.BaseModel `bun:"table:agent_config_element"`
+
+	types.Identifiable
+	types.TimeAuditable
+	ElementID   string      `bun:"element_id,type:text,notnull,unique:element_type_version_idx"`
+	ElementType string      `bun:"element_type,type:text,notnull,unique:element_type_version_idx"`
+	VersionID   valuer.UUID `bun:"version_id,type:text,notnull,unique:element_type_version_idx"`
 }

tests/integration/fixtures/cloudintegrations.py

@@ -1,7 +1,7 @@
 """Fixtures for cloud integration tests."""
 
 from http import HTTPStatus
-from typing import Callable
+from typing import Callable, Optional
 
 import pytest
 import requests
@@ -18,12 +18,14 @@ def create_cloud_integration_account(
     request: pytest.FixtureRequest,
     signoz: types.SigNoz,
 ) -> Callable[[str, str], dict]:
-    created_accounts: list[tuple[str, str]] = []
+    created_account_id: Optional[str] = None
+    cloud_provider_used: Optional[str] = None
 
     def _create(
         admin_token: str,
         cloud_provider: str = "aws",
     ) -> dict:
+        nonlocal created_account_id, cloud_provider_used
         endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/generate-connection-url"
 
         request_payload = {
@@ -50,31 +52,35 @@ def create_cloud_integration_account(
         ), f"Failed to create test account: {response.status_code}"
 
         data = response.json().get("data", response.json())
-        created_accounts.append((data.get("account_id"), cloud_provider))
+        created_account_id = data.get("account_id")
+        cloud_provider_used = cloud_provider
 
         return data
 
+    def _disconnect(admin_token: str, cloud_provider: str) -> requests.Response:
+        assert created_account_id
+        disconnect_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{created_account_id}/disconnect"
+        return requests.post(
+            signoz.self.host_configs["8080"].get(disconnect_endpoint),
+            headers={"Authorization": f"Bearer {admin_token}"},
+            timeout=10,
+        )
+
     # Yield factory to the test
     yield _create
 
-    # Post-test cleanup: disconnect all created accounts
-    if created_accounts:
+    # Post-test cleanup: generate admin token and disconnect the created account
+    if created_account_id and cloud_provider_used:
         get_token = request.getfixturevalue("get_token")
         try:
             admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-            for account_id, cloud_provider in created_accounts:
-                disconnect_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts/{account_id}/disconnect"
-                r = requests.post(
-                    signoz.self.host_configs["8080"].get(disconnect_endpoint),
-                    headers={"Authorization": f"Bearer {admin_token}"},
-                    timeout=10,
+            r = _disconnect(admin_token, cloud_provider_used)
+            if r.status_code != HTTPStatus.OK:
+                logger.info(
+                    "Disconnect cleanup returned %s for account %s",
+                    r.status_code,
+                    created_account_id,
                 )
-                if r.status_code != HTTPStatus.OK:
-                    logger.info(
-                        "Disconnect cleanup returned %s for account %s",
-                        r.status_code,
-                        account_id,
-                    )
-                logger.info("Cleaned up test account: %s", account_id)
+            logger.info("Cleaned up test account: %s", created_account_id)
         except Exception as exc:  # pylint: disable=broad-except
             logger.info("Post-test disconnect cleanup failed: %s", exc)

tests/integration/fixtures/cloudintegrationsutils.py

@@ -1,5 +1,7 @@
 """Fixtures for cloud integration tests."""
 
+from http import HTTPStatus
+
 import requests
 
 from fixtures import types
@@ -14,7 +16,7 @@ def simulate_agent_checkin(
     cloud_provider: str,
     account_id: str,
     cloud_account_id: str,
-) -> requests.Response:
+) -> dict:
     endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/agent-check-in"
 
     checkin_payload = {
@@ -30,11 +32,16 @@ def simulate_agent_checkin(
         timeout=10,
     )
 
-    if not response.ok:
+    if response.status_code != HTTPStatus.OK:
         logger.error(
             "Agent check-in failed: %s, response: %s",
             response.status_code,
             response.text,
         )
 
-    return response
+    assert (
+        response.status_code == HTTPStatus.OK
+    ), f"Agent check-in failed: {response.status_code}"
+
+    response_data = response.json()
+    return response_data.get("data", response_data)

tests/integration/src/cloudintegrations/02_generate_connection_url.py

@@ -1,4 +1,3 @@
-import uuid
 from http import HTTPStatus
 from typing import Callable
 
@@ -6,8 +5,6 @@ import requests
 
 from fixtures import types
 from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.cloudintegrations import create_cloud_integration_account
-from fixtures.cloudintegrationsutils import simulate_agent_checkin
 from fixtures.logger import setup_logger
 
 logger = setup_logger(__name__)
@@ -145,42 +142,3 @@ def test_generate_connection_url_unsupported_provider(
     assert (
         "unsupported cloud provider" in response_data["error"].lower()
     ), "Error message should indicate unsupported provider"
-
-
-def test_duplicate_cloud_account_checkins(
-    signoz: types.SigNoz,
-    create_user_admin: types.Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    create_cloud_integration_account: Callable,
-) -> None:
-    """Test that two accounts cannot check in with the same cloud_account_id."""
-
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    cloud_provider = "aws"
-    same_cloud_account_id = str(uuid.uuid4())
-
-    # Create two separate cloud integration accounts via generate-connection-url
-    account1 = create_cloud_integration_account(admin_token, cloud_provider)
-    account1_id = account1["account_id"]
-
-    account2 = create_cloud_integration_account(admin_token, cloud_provider)
-    account2_id = account2["account_id"]
-
-    assert account1_id != account2_id, "Two accounts should have different internal IDs"
-
-#     First check-in succeeds: account1 claims cloud_account_id
-    response = simulate_agent_checkin(
-        signoz, admin_token, cloud_provider, account1_id, same_cloud_account_id
-    )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for first check-in, got {response.status_code}: {response.text}"
-#
-    # Second check-in should fail: account2 tries to use the same cloud_account_id
-    response = simulate_agent_checkin(
-        signoz, admin_token, cloud_provider, account2_id, same_cloud_account_id
-    )
-
-    assert (
-        response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
-    ), f"Expected 500 for duplicate cloud_account_id, got {response.status_code}: {response.text}"

tests/integration/src/cloudintegrations/03_accounts.py

@@ -57,12 +57,9 @@ def test_list_connected_accounts_with_account(
 
     # Simulate agent check-in to mark as connected
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # List accounts
     endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/accounts"
@@ -164,12 +161,9 @@ def test_update_account_config(
 
     # Simulate agent check-in to mark as connected
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Update account configuration
     endpoint = (
@@ -232,12 +226,9 @@ def test_disconnect_account(
 
     # Simulate agent check-in to mark as connected
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Disconnect the account
     endpoint = (

tests/integration/src/cloudintegrations/04_services.py

@@ -61,12 +61,9 @@ def test_list_services_with_account(
     account_id = account_data["account_id"]
 
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # List services for the account
     endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services?cloud_account_id={cloud_account_id}"
@@ -155,12 +152,9 @@ def test_get_service_details_with_account(
     account_id = account_data["account_id"]
 
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Get list of services first
     list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
@@ -259,12 +253,9 @@ def test_update_service_config(
     account_id = account_data["account_id"]
 
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Get list of services to pick a valid service ID
     list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"
@@ -374,12 +365,9 @@ def test_update_service_config_invalid_service(
     account_id = account_data["account_id"]
 
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Try to update config for invalid service
     fake_service_id = "non-existent-service"
@@ -421,12 +409,9 @@ def test_update_service_config_disable_service(
     account_id = account_data["account_id"]
 
     cloud_account_id = str(uuid.uuid4())
-    response = simulate_agent_checkin(
+    simulate_agent_checkin(
         signoz, admin_token, cloud_provider, account_id, cloud_account_id
     )
-    assert (
-        response.status_code == HTTPStatus.OK
-    ), f"Expected 200 for agent check-in, got {response.status_code}: {response.text}"
 
     # Get a valid service
     list_endpoint = f"/api/v1/cloud-integrations/{cloud_provider}/services"

tests/integration/src/passwordauthn/01_register.py

@@ -121,6 +121,23 @@ def test_invite_and_register(
     assert invited_user["email"] == "editor@integration.test"
     assert invited_user["role"] == "EDITOR"
 
+    # Verify the user user appears in the users list but as pending_invite status
+    response = requests.get(
+        signoz.self.host_configs["8080"].get("/api/v1/user"),
+        timeout=2,
+        headers={"Authorization": f"Bearer {admin_token}"},
+    )
+    assert response.status_code == HTTPStatus.OK
+
+    user_response = response.json()["data"]
+    found_user = next(
+        (user for user in user_response if user["email"] == "editor@integration.test"),
+        None,
+    )
+    assert found_user is not None
+    assert found_user["status"] == "pending_invite"
+    assert found_user["role"] == "EDITOR"
+
     reset_token = invited_user["token"]
 
     # Reset the password to complete the invite flow (activates the user and also grants authz)
@@ -231,85 +248,3 @@ def test_self_access(
 
     assert response.status_code == HTTPStatus.OK
     assert response.json()["data"]["role"] == "EDITOR"
-
-
-def test_old_invite_flow(signoz: types.SigNoz, get_token: Callable[[str, str], str]):
-    admin_token = get_token("admin@integration.test", "password123Z$")
-
-    # invite a new user
-    response = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v1/invite"),
-        json={"email": "oldinviteflow@integration.test", "role": "VIEWER", "name": "old invite flow"},
-        timeout=2,
-        headers={"Authorization": f"Bearer {admin_token}"},
-    )
-    assert response.status_code == HTTPStatus.CREATED
-
-    # get the invite token using get api
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v1/invite"),
-        timeout=2,
-        headers={
-            "Authorization": f"Bearer {admin_token}"
-        },
-    )
-
-    invite_response = response.json()["data"]
-    found_invite = next(
-        (
-            invite
-            for invite in invite_response
-            if invite["email"] == "oldinviteflow@integration.test"
-        ),
-        None,
-    )
-
-    # accept the invite
-    response = requests.post(
-        signoz.self.host_configs["8080"].get("/api/v1/invite/accept"),
-        json={
-            "password": "password123Z$",
-            "displayName": "old invite flow",
-            "token": f"{found_invite['token']}",
-        },
-        timeout=2,
-    )
-    assert response.status_code == HTTPStatus.CREATED
-
-    # verify the invite token has been deleted
-    response = requests.get(
-        signoz.self.host_configs["8080"].get(f"/api/v1/invite/{found_invite['token']}"),
-        timeout=2,
-    )
-    assert response.status_code in (HTTPStatus.NOT_FOUND, HTTPStatus.BAD_REQUEST)
-
-    # verify that admin endpoints cannot be called
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v1/user"),
-        timeout=2,
-        headers={
-            "Authorization": f"Bearer {get_token("oldinviteflow@integration.test", "password123Z$")}"
-        },
-    )
-    assert response.status_code == HTTPStatus.FORBIDDEN
-
-    # verify the user has been created
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v1/user"),
-        timeout=2,
-        headers={
-            "Authorization": f"Bearer {admin_token}"
-        },
-    )
-    assert response.status_code == HTTPStatus.OK
-
-    user_response = response.json()["data"]
-    found_user = next(
-        (user for user in user_response if user["email"] == "oldinviteflow@integration.test"),
-        None,
-    )
-
-    assert found_user is not None
-    assert found_user["role"] == "VIEWER"
-    assert found_user["displayName"] == "old invite flow"
-    assert found_user["email"] == "oldinviteflow@integration.test"