Merge branch 'main' into fix/validate_alert_payload_before_saving

pkg/query-service/app/http_handler.go

@@ -1407,6 +1407,10 @@ 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
 	}
@@ -1437,6 +1441,10 @@ 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
 	}
@@ -1457,6 +1465,10 @@ 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,6 +608,13 @@ 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)
@@ -621,29 +628,6 @@ 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)
@@ -735,6 +719,18 @@ 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
+		// TODO: errors returned here is errors.errorString, rather than using regex to parser the error
 		// we should think on using some other library that parses the CH query in more accurate manner,
-		// current CH parser does very minimal checks and on just the known keywords, without validating the syntax of given query.
+		// current CH parser only does very minimal checks.
 		// 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,8 +26,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "empty queries array should return error",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{},
 			},
 			wantErr:     true,
@@ -36,8 +34,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "invalid input error",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Unit: "some_invalid_unit",
 				Queries: []qbtypes.QueryEnvelope{
 					{
@@ -55,8 +51,6 @@ 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{
 					{
@@ -78,8 +72,6 @@ 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{
 					{
@@ -101,8 +93,6 @@ 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{
 					{
@@ -124,8 +114,6 @@ 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{
 					{
@@ -142,8 +130,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid ClickHouse query should pass",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeClickHouseSQL,
@@ -159,8 +145,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "valid formula query should pass",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeFormula,
@@ -173,12 +157,9 @@ 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,
@@ -192,14 +173,11 @@ func TestValidateCompositeQuery(t *testing.T) {
 					},
 				},
 			},
-			wantErr: true,
-			errContains: "unknown query type",
+			wantErr: false,
 		},
 		{
 			name: "valid trace operator query should pass",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -239,8 +217,6 @@ 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,
@@ -258,8 +234,6 @@ 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,
@@ -276,8 +250,6 @@ 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,
@@ -294,8 +266,6 @@ 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,
@@ -312,8 +282,6 @@ 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,
@@ -330,8 +298,6 @@ 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,
@@ -348,8 +314,6 @@ 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,
@@ -366,8 +330,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "all queries disabled should return error",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -398,8 +360,6 @@ 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,
@@ -429,8 +389,6 @@ func TestValidateCompositeQuery(t *testing.T) {
 		{
 			name: "multiple valid queries should pass",
 			compositeQuery: &CompositeQuery{
-				QueryType: QueryTypeBuilder,
-				PanelType: PanelTypeGraph,
 				Queries: []qbtypes.QueryEnvelope{
 					{
 						Type: qbtypes.QueryTypeBuilder,
@@ -465,8 +423,6 @@ 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,
@@ -495,8 +451,6 @@ 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,6 +353,11 @@ 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
@@ -552,6 +557,11 @@ 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{
@@ -940,6 +950,11 @@ 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))
@@ -990,6 +1005,12 @@ 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, start, end)
+		querytemplate.AssignReservedVars(params.Variables, params.Start, params.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 checks if the QueryBuilderFormula fields are valid
+// Validate validates the QueryBuilderFormula
 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 checks if the FunctionName is valid and one of the known types
+// Validate validates that the FunctionName is one of the known types
 func (fn FunctionName) Validate() error {
 	switch fn {
 	case FunctionNameCutOffMin,

pkg/types/querybuildertypes/querybuildertypesv5/join.go

@@ -1,6 +1,9 @@
 package querybuildertypesv5
 
 import (
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -16,6 +19,15 @@ 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"`
 }
@@ -53,6 +65,25 @@ 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,6 +8,7 @@ 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"
@@ -121,6 +122,107 @@ 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,6 +304,39 @@ 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
@@ -359,6 +392,26 @@ 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,8 +111,10 @@ func TestParseIntoRule(t *testing.T) {
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
+						"panelType": "graph",
 						"builderQueries": {
 							"A": {
+								"queryName": "A",
 								"expression": "A",
 								"disabled": false,
 								"aggregateAttribute": {
@@ -149,10 +151,12 @@ 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,
@@ -187,9 +191,11 @@ 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])",
@@ -255,10 +261,12 @@ 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": {
@@ -343,10 +351,12 @@ 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": {
@@ -383,10 +393,12 @@ 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": {
@@ -405,7 +417,7 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 						"spec": [{
 							"name": "existing_threshold",
 							"target": 50.0,
-							"targetUnit": "MBs",
+							"targetUnit": "MB",
 							"ruleUnit": "bytes",
 							"matchType": "1",
 							"op": "1"
@@ -473,10 +485,12 @@ 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": {
@@ -517,9 +531,11 @@ func TestParseIntoRuleSchemaVersioning(t *testing.T) {
 			initRule: PostableRule{},
 			content: []byte(`{
 				"alert": "DefaultSchemaTest",
+				"alertType": "METRIC_BASED_ALERT",
 				"condition": {
 					"compositeQuery": {
 						"queryType": "builder",
+						"panelType": "graph",
 						"builderQueries": {
 							"A": {
 								"aggregateAttribute": {
@@ -569,12 +585,16 @@ 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"
@@ -638,14 +658,18 @@ 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"
@@ -731,10 +755,12 @@ 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": {
@@ -765,10 +791,12 @@ 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": {
@@ -798,10 +826,12 @@ 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": {
@@ -832,10 +862,12 @@ 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": {
@@ -865,10 +897,12 @@ 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": {
@@ -900,10 +934,12 @@ 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": {
@@ -934,10 +970,12 @@ 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": {
@@ -968,10 +1006,12 @@ 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": {
@@ -1002,10 +1042,12 @@ 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": {