chore: updated comment

pkg/query-service/app/http_handler.go

@@ -1407,10 +1407,6 @@ func (aH *APIHandler) patchRule(w http.ResponseWriter, r *http.Request) {
 			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
 			return
 		}
-		if apiErr, ok := err.(*model.ApiError); ok {
-			RespondError(w, apiErr, nil)
-			return
-		}
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
 		return
 	}
@@ -1441,10 +1437,6 @@ func (aH *APIHandler) editRule(w http.ResponseWriter, r *http.Request) {
 			RespondError(w, &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("rule not found")}, nil)
 			return
 		}
-		if apiErr, ok := err.(*model.ApiError); ok {
-			RespondError(w, apiErr, nil)
-			return
-		}
 		RespondError(w, &model.ApiError{Typ: model.ErrorInternal, Err: err}, nil)
 		return
 	}
@@ -1465,10 +1457,6 @@ func (aH *APIHandler) createRule(w http.ResponseWriter, r *http.Request) {
 
 	rule, err := aH.ruleManager.CreateRule(r.Context(), string(body))
 	if err != nil {
-		if apiErr, ok := err.(*model.ApiError); ok {
-			RespondError(w, apiErr, nil)
-			return
-		}
 		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, nil)
 		return
 	}

pkg/query-service/model/v3/v3.go

@@ -608,13 +608,6 @@ func (c *CompositeQuery) Validate() error {
 		)
 	}
 
-	if len(c.Queries) == 0 {
-		return errors.NewInvalidInputf(
-			errors.CodeInvalidInput,
-			"at least one query is required",
-		)
-	}
-
 	// Validate unit if supplied
 	if c.Unit != "" {
 		unit := converter.Unit(c.Unit)
@@ -628,6 +621,29 @@ func (c *CompositeQuery) Validate() error {
 		}
 	}
 
+	if err := c.PanelType.Validate(); err != nil {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"panel type is invalid: %s",
+			err.Error(),
+		)
+	}
+
+	if err := c.QueryType.Validate(); err != nil {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"query type is invalid: %s",
+			err.Error(),
+		)
+	}
+
+	if len(c.Queries) == 0 {
+		return errors.NewInvalidInputf(
+			errors.CodeInvalidInput,
+			"at least one query is required",
+		)
+	}
+
 	// Validate each query
 	for i, envelope := range c.Queries {
 		queryId := qbtypes.GetQueryIdentifier(envelope, i)
@@ -719,18 +735,6 @@ func (c *CompositeQuery) Validate() error {
 			if err := spec.Validate(); err != nil {
 				return err
 			}
-		case qbtypes.QueryTypeJoin:
-			spec, ok := envelope.Spec.(qbtypes.QueryBuilderJoin)
-			if !ok {
-				return errors.NewInvalidInputf(
-					errors.CodeInvalidInput,
-					"invalid spec for %s",
-					queryId,
-				)
-			}
-			if err := spec.Validate(); err != nil {
-				return err
-			}
 		case qbtypes.QueryTypeTraceOperator:
 			spec, ok := envelope.Spec.(qbtypes.QueryBuilderTraceOperator)
 			if !ok {

pkg/query-service/model/v3/validation.go

@@ -78,9 +78,9 @@ func validateClickHouseQuery(query string) error {
 	p := clickhouse.NewParser(queryBuffer.String())
 	_, err = p.ParseStmts()
 	if err != nil {
-		// TODO: errors returned here is errors.errorString, rather than using regex to parser the error
+		// TODO: errors returned here is errors.errorString
 		// we should think on using some other library that parses the CH query in more accurate manner,
-		// current CH parser only does very minimal checks.
+		// current CH parser does very minimal checks and on just the known keywords, without validating the syntax of given query.
 		// Sample Error: "line 0:36 expected table name or subquery, got ;\nSELECT department, avg(salary) FROM ;\n                                    ^\n"
 		return &QueryParseError{
 			ErrorMessage: err.Error(),

pkg/query-service/model/v3/validation_test.go

@@ -26,6 +26,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "empty queries array should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{},
 			},
 			wantErr:     true,
@@ -34,6 +36,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid input error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Unit: "some_invalid_unit",
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -51,6 +55,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid metric builder query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Unit: "bytes", // valid unit
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -72,6 +78,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid log builder query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Unit: "µs", // valid unit
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -93,6 +101,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid trace builder query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Unit: "MBs", // valid unit
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -114,6 +124,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid PromQL query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Unit: "{req}/s", // valid unit
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -130,6 +142,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid ClickHouse query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeClickHouseSQL,
@@ -145,6 +159,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid formula query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeFormula,
@@ -157,9 +173,12 @@ func TestValidateCompositeQuery(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		// We've not added support for join query yet
 		{
 			name: "valid join query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeJoin,
@@ -173,11 +192,14 @@ func TestValidateCompositeQuery(t *testing.T) {
 					},
 				},
 			},
-			wantErr: false,
+			wantErr: true,
+			errContains: "unknown query type",
 		},
 		{
 			name: "valid trace operator query should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -217,6 +239,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid metric builder query - missing aggregation should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -234,6 +258,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid PromQL query - empty query should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypePromQL,
@@ -250,6 +276,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid PromQL query - syntax error should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypePromQL,
@@ -266,6 +294,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid ClickHouse query - empty query should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeClickHouseSQL,
@@ -282,6 +312,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid ClickHouse query - syntax error should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeClickHouseSQL,
@@ -298,6 +330,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid formula query - empty expression should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeFormula,
@@ -314,6 +348,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid trace operator query - empty expression should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeTraceOperator,
@@ -330,6 +366,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "all queries disabled should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -360,6 +398,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "mixed disabled and enabled queries should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -389,6 +429,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "multiple valid queries should pass",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -423,6 +465,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid query in multiple queries should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -451,6 +495,8 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "unknown query type should return error",
 			compositeQuery: &CompositeQuery{
+				QueryType: QueryTypeBuilder,
+				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryType{String: valuer.NewString("invalid_query_type")},

pkg/query-service/rules/manager.go

@@ -353,11 +353,6 @@ func (m *Manager) EditRule(ctx context.Context, ruleStr string, id valuer.UUID)
 		return err
 	}
 
-	err = parsedRule.RuleCondition.CompositeQuery.Validate()
-	if err != nil {
-		return model.BadRequest(err)
-	}
-
 	existingRule, err := m.ruleStore.GetStoredRule(ctx, id)
 	if err != nil {
 		return err
@@ -557,11 +552,6 @@ func (m *Manager) CreateRule(ctx context.Context, ruleStr string) (*ruletypes.Ge
 		return nil, err
 	}
 
-	err = parsedRule.RuleCondition.CompositeQuery.Validate()
-	if err != nil {
-		return nil, model.BadRequest(err)
-	}
-
 	now := time.Now()
 	storedRule := &ruletypes.Rule{
 		Identifiable: types.Identifiable{
@@ -950,11 +940,6 @@ func (m *Manager) PatchRule(ctx context.Context, ruleStr string, id valuer.UUID)
 		return nil, err
 	}
 
-	err = storedRule.RuleCondition.CompositeQuery.Validate()
-	if err != nil {
-		return nil, model.BadRequest(err)
-	}
-
 	// deploy or un-deploy task according to patched (new) rule state
 	if err := m.syncRuleStateWithTask(ctx, orgID, taskName, &storedRule); err != nil {
 		zap.L().Error("failed to sync stored rule state with the task", zap.String("taskName", taskName), zap.Error(err))
@@ -1005,12 +990,6 @@ func (m *Manager) TestNotification(ctx context.Context, orgID valuer.UUID, ruleS
 	if err != nil {
 		return 0, model.BadRequest(err)
 	}
-
-	err = parsedRule.RuleCondition.CompositeQuery.Validate()
-	if err != nil {
-		return 0, model.BadRequest(err)
-	}
-
 	if !parsedRule.NotificationSettings.UsePolicy {
 		parsedRule.NotificationSettings.GroupBy = append(parsedRule.NotificationSettings.GroupBy, ruletypes.LabelThresholdName)
 	}

pkg/query-service/rules/prom_rule.go

@@ -159,7 +159,7 @@ func (r *PromRule) buildAndRunQuery(ctx context.Context, ts time.Time) (ruletype
 	var resultVector ruletypes.Vector
 	for _, series := range matrixToProcess {
 		resultSeries, err := r.Threshold.Eval(*series, r.Unit(), ruletypes.EvalData{
-		  ActiveAlerts:  r.ActiveAlertsLabelFP(),
+			ActiveAlerts:  r.ActiveAlertsLabelFP(),
       SendUnmatched: r.ShouldSendUnmatched(),
 		})
 		if err != nil {

pkg/query-service/rules/threshold_rule.go

@@ -133,7 +133,7 @@ func (r *ThresholdRule) prepareQueryRange(ctx context.Context, ts time.Time) (*v
 			Variables: make(map[string]interface{}, 0),
 			NoCache:   true,
 		}
-		querytemplate.AssignReservedVars(params.Variables, params.Start, params.End)
+		querytemplate.AssignReservedVars(params.Variables, start, end)
 		for name, chQuery := range r.ruleCondition.CompositeQuery.ClickHouseQueries {
 			if chQuery.Disabled {
 				continue

pkg/types/querybuildertypes/querybuildertypesv5/formula.go

@@ -73,7 +73,7 @@ func (f *QueryBuilderFormula) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Validate validates the QueryBuilderFormula
+// Validate checks if the QueryBuilderFormula fields are valid
 func (f QueryBuilderFormula) Validate() error {
 	// Validate name is not blank
 	if strings.TrimSpace(f.Name) == "" {

pkg/types/querybuildertypes/querybuildertypesv5/functions.go

@@ -34,7 +34,7 @@ var (
 	FunctionNameFillZero      = FunctionName{valuer.NewString("fillZero")}
 )
 
-// Validate validates that the FunctionName is one of the known types
+// Validate checks if the FunctionName is valid and one of the known types
 func (fn FunctionName) Validate() error {
 	switch fn {
 	case FunctionNameCutOffMin,

pkg/types/querybuildertypes/querybuildertypesv5/join.go

@@ -1,9 +1,6 @@
 package querybuildertypesv5
 
 import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -19,15 +16,6 @@ var (
 	JoinTypeCross = JoinType{valuer.NewString("cross")}
 )
 
-func (j JoinType) Validate() error {
-	switch j {
-	case JoinTypeInner, JoinTypeLeft, JoinTypeRight, JoinTypeFull, JoinTypeCross:
-		return nil
-	default:
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid join type: %s, supported values: inner, left, right, full, cross", j.StringValue())
-	}
-}
-
 type QueryRef struct {
 	Name string `json:"name"`
 }
@@ -65,25 +53,6 @@ type QueryBuilderJoin struct {
 	Functions             []Function             `json:"functions,omitempty"`
 }
 
-func (q *QueryBuilderJoin) Validate() error {
-	if strings.TrimSpace(q.Name) == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "name is required")
-	}
-	if strings.TrimSpace(q.Left.Name) == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "left name is required")
-	}
-	if strings.TrimSpace(q.Right.Name) == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "right name is required")
-	}
-	if err := q.Type.Validate(); err != nil {
-		return err
-	}
-	if strings.TrimSpace(q.On) == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "on is required")
-	}
-	return nil
-}
-
 // Copy creates a deep copy of QueryBuilderJoin
 func (q QueryBuilderJoin) Copy() QueryBuilderJoin {
 	c := q

pkg/types/ruletypes/alerting.go

@@ -8,7 +8,6 @@ import (
 	"strings"
 	"time"
 
-	signozError "github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/query-service/model"
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/query-service/utils/labels"
@@ -122,107 +121,6 @@ type RuleCondition struct {
 	Thresholds        *RuleThresholdData `json:"thresholds,omitempty"`
 }
 
-func (rc *RuleCondition) UnmarshalJSON(data []byte) error {
-	type Alias RuleCondition
-	aux := (*Alias)(rc)
-	if err := json.Unmarshal(data, aux); err != nil {
-		return signozError.NewInvalidInputf(signozError.CodeInvalidInput, "failed to parse rule condition json: %v", err)
-	}
-
-	var errs []error
-
-	// Validate CompositeQuery - must be non-nil and pass validation
-	if rc.CompositeQuery == nil {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "composite query is required"))
-	}
-
-	// Validate AlertOnAbsent + AbsentFor - if AlertOnAbsent is true, AbsentFor must be > 0
-	if rc.AlertOnAbsent && rc.AbsentFor == 0 {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "absentFor must be greater than 0 when alertOnAbsent is true"))
-	}
-
-	// Validate Seasonality - must be one of the allowed values when provided
-	if !isValidSeasonality(rc.Seasonality) {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "invalid seasonality: %s, supported values: hourly, daily, weekly", rc.Seasonality))
-	}
-
-	// Validate SelectedQueryName - must match one of the query names from CompositeQuery
-	if rc.SelectedQuery != "" && rc.CompositeQuery != nil {
-		queryNames := getAllQueryNames(rc.CompositeQuery)
-		if _, exists := queryNames[rc.SelectedQuery]; !exists {
-			errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "selected query name '%s' does not match any query in composite query", rc.SelectedQuery))
-		}
-	}
-
-	// Validate RequireMinPoints + RequiredNumPoints - if RequireMinPoints is true, RequiredNumPoints must be > 0
-	if rc.RequireMinPoints && rc.RequiredNumPoints <= 0 {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "requiredNumPoints must be greater than 0 when requireMinPoints is true"))
-	}
-
-	if len(errs) > 0 {
-		return signozError.Join(errs...)
-	}
-
-	return nil
-}
-
-// getAllQueryNames extracts all query names from CompositeQuery across all query types
-// Returns a map of query names for quick lookup
-func getAllQueryNames(compositeQuery *v3.CompositeQuery) map[string]struct{} {
-	queryNames := make(map[string]struct{})
-
-	// Extract names from Queries (v5 envelopes)
-	if compositeQuery != nil && compositeQuery.Queries != nil {
-		for _, query := range compositeQuery.Queries {
-			switch spec := query.Spec.(type) {
-			case qbtypes.QueryBuilderQuery[qbtypes.TraceAggregation]:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.QueryBuilderQuery[qbtypes.LogAggregation]:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.QueryBuilderQuery[qbtypes.MetricAggregation]:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.QueryBuilderFormula:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.QueryBuilderTraceOperator:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.PromQuery:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			case qbtypes.ClickHouseQuery:
-				if spec.Name != "" {
-					queryNames[spec.Name] = struct{}{}
-				}
-			}
-		}
-	}
-
-	return queryNames
-}
-
-// isValidSeasonality validates that Seasonality is one of the allowed values
-func isValidSeasonality(seasonality string) bool {
-	if seasonality == "" {
-		return true // empty seasonality is allowed (optional field)
-	}
-	switch seasonality {
-	case "hourly", "daily", "weekly":
-		return true
-	default:
-		return false
-	}
-}
-
 func (rc *RuleCondition) GetSelectedQueryName() string {
 	if rc != nil {
 		if rc.SelectedQuery != "" {

pkg/types/ruletypes/api_params.go

@@ -304,39 +304,6 @@ func isValidLabelValue(v string) bool {
 	return utf8.ValidString(v)
 }
 
-// isValidAlertType validates that the AlertType is one of the allowed enum values
-func isValidAlertType(alertType AlertType) bool {
-	switch alertType {
-	case AlertTypeMetric, AlertTypeTraces, AlertTypeLogs, AlertTypeExceptions:
-		return true
-	default:
-		return false
-	}
-}
-
-// isValidRuleType validates that the RuleType is one of the allowed enum values
-func isValidRuleType(ruleType RuleType) bool {
-	switch ruleType {
-	case RuleTypeThreshold, RuleTypeProm, RuleTypeAnomaly:
-		return true
-	default:
-		return false
-	}
-}
-
-// isValidVersion validates that the version is one of the supported versions
-func isValidVersion(version string) bool {
-	if version == "" {
-		return true // empty version is allowed (optional field)
-	}
-	switch version {
-	case "v3", "v4", "v5":
-		return true
-	default:
-		return false
-	}
-}
-
 func isAllQueriesDisabled(compositeQuery *v3.CompositeQuery) bool {
 	if compositeQuery == nil {
 		return false
@@ -392,26 +359,6 @@ func (r *PostableRule) validate() error {
 		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "all queries are disabled in rule condition"))
 	}
 
-	// Validate AlertName - required field
-	if r.AlertName == "" {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "alert name is required"))
-	}
-
-	// Validate AlertType - must be one of the allowed enum values
-	if !isValidAlertType(r.AlertType) {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "invalid alert type: %s, must be one of: METRIC_BASED_ALERT, TRACES_BASED_ALERT, LOGS_BASED_ALERT, EXCEPTIONS_BASED_ALERT", r.AlertType))
-	}
-
-	// Validate RuleType - must be one of the allowed enum values
-	if !isValidRuleType(r.RuleType) {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "invalid rule type: %s, must be one of: threshold_rule, promql_rule, anomaly_rule", r.RuleType))
-	}
-
-	// Validate Version - must be one of the supported versions if provided
-	if !isValidVersion(r.Version) {
-		errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "invalid version: %s, must be one of: v3, v4, v5", r.Version))
-	}
-
 	for k, v := range r.Labels {
 		if !isValidLabelName(k) {
 			errs = append(errs, signozError.NewInvalidInputf(signozError.CodeInvalidInput, "invalid label name: %s", k))

pkg/types/ruletypes/api_params_test.go

@@ -111,10 +111,8 @@ func TestParseIntoRule(t *testing.T) {
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
-								"queryName": "A",
 								"expression": "A",
 								"disabled": false,
 								"aggregateAttribute": {
@@ -151,12 +149,10 @@ func TestParseIntoRule(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "DefaultsRule",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "threshold_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"disabled": false,
@@ -191,11 +187,9 @@ func TestParseIntoRule(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "PromQLRule",
-				"alertType": "METRIC_BASED_ALERT",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "promql",
-						"panelType": "graph",
 						"promQueries": {
 							"A": {
 								"query": "rate(http_requests_total[5m])",
@@ -261,12 +255,10 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "SeverityLabelTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"schemaVersion": "v1",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -351,12 +343,10 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "NoLabelsTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"schemaVersion": "v1",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -393,12 +383,10 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "OverwriteTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"schemaVersion": "v1",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -417,7 +405,7 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 						"spec": [{
 							"name": "existing_threshold",
 							"target": 50.0,
-							"targetUnit": "MB",
+							"targetUnit": "MBs",
 							"ruleUnit": "bytes",
 							"matchType": "1",
 							"op": "1"
@@ -485,12 +473,10 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "V2Test",
-				"alertType": "METRIC_BASED_ALERT",
 				"schemaVersion": "v2",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -531,11 +517,9 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "DefaultSchemaTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -585,16 +569,12 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 func TestParseIntoRuleThresholdGeneration(t *testing.T) {
 	content := []byte(`{
 		"alert": "TestThresholds",
-		"alertType": "METRIC_BASED_ALERT",
 		"condition": {
 			"compositeQuery": {
 				"queryType": "builder",
-				"panelType": "graph",
 				"builderQueries": {
 					"A": {
-						"queryName": "A",
 						"expression": "A",
-						"dataSource": "metrics",
 						"disabled": false,
 						"aggregateAttribute": {
 							"key": "response_time"
@@ -658,18 +638,14 @@ func TestParseIntoRuleMultipleThresholds(t *testing.T) {
 	content := []byte(`{
 		"schemaVersion": "v2",
 		"alert": "MultiThresholdAlert",
-		"alertType": "METRIC_BASED_ALERT",
 		"ruleType": "threshold_rule",
 		"condition": {
 			"compositeQuery": {
 				"queryType": "builder",
-				"panelType": "graph",
 				"unit": "%",
 				"builderQueries": {
 					"A": {
-						"queryName": "A",
 						"expression": "A",
-						"dataSource": "metrics",
 						"disabled": false,
 						"aggregateAttribute": {
 							"key": "cpu_usage"
@@ -755,12 +731,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsBelow - should alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyBelowTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -791,12 +765,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsBelow; should not alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyBelowTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -826,12 +798,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsAbove; should alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyAboveTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -862,12 +832,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsAbove; should not alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyAboveTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -897,12 +865,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsBelow and AllTheTimes; should alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyBelowAllTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -934,12 +900,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueIsBelow and AllTheTimes; should not alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyBelowAllTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -970,12 +934,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "anomaly rule with ValueOutsideBounds; should alert",
 			ruleJSON: []byte(`{
 				"alert": "AnomalyOutOfBoundsTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "anomaly_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -1006,12 +968,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "non-anomaly threshold rule with ValueIsBelow; should alert",
 			ruleJSON: []byte(`{
 				"alert": "ThresholdTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "threshold_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {
@@ -1042,12 +1002,10 @@ func TestAnomalyNegationEval(t *testing.T) {
 			name: "non-anomaly rule with ValueIsBelow - should not alert",
 			ruleJSON: []byte(`{
 				"alert": "ThresholdTest",
-				"alertType": "METRIC_BASED_ALERT",
 				"ruleType": "threshold_rule",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
-						"panelType": "graph",
 						"queries": [{
 							"type": "builder_query",
 							"spec": {