make frequency minute and hour consistent with the rest with '-ly'

Author: rizqme

docs/README.md

@@ -0,0 +1,21 @@
+## Schedule Frequency Options
+
+The `frequency` field in a schedule supports the following values:
+
+- `minutely`: Every N minutes
+- `hourly`: Every N hours
+- `daily`: Every N days
+- `weekly`: Every N weeks
+- `monthly`: Every N months
+- `yearly`: Every N years
+
+Example schedule JSON:
+
+```json
+{
+  "frequency": "hourly",
+  "interval": 2
+}
+```
+
+This will schedule the event every 2 hours. 

internal/scheduler/expander.go

@@ -130,13 +130,13 @@ func (e *Expander) expandRecurringEvent(ctx context.Context, event *models.Event
 
 	// Calculate occurrences based on frequency
 	switch schedule.Frequency {
-	case "minute":
+	case "minutely":
 		for t := startTime; t.Before(endTime); t = t.Add(time.Duration(schedule.Interval) * time.Minute) {
 			if t.After(graceStart) {
 				occurrences = append(occurrences, t)
 			}
 		}
-	case "hour":
+	case "hourly":
 		for t := startTime; t.Before(endTime); t = t.Add(time.Duration(schedule.Interval) * time.Hour) {
 			if t.After(graceStart) {
 				occurrences = append(occurrences, t)

internal/scheduler/expander_test.go

@@ -328,4 +328,60 @@ func TestEventExpander(t *testing.T) {
 		assert.Contains(t, scheduledDays, time.Wednesday)
 		assert.NotContains(t, scheduledDays, time.Monday)
 	})
+
+	t.Run("minutely frequency event expansion", func(t *testing.T) {
+		cleanup()
+		startTime := time.Now().Truncate(time.Minute)
+		scheduleConfig := &models.ScheduleConfig{
+			Frequency: "minutely",
+			Interval:  2,
+		}
+		event := &models.Event{
+			ID:          uuid.New(),
+			Name:        "Minutely Event",
+			Description: "Every 2 minutes",
+			StartTime:   startTime,
+			Webhook:     "http://example.com",
+			Schedule:    scheduleConfig,
+			Status:      models.EventStatusActive,
+			Metadata:    []byte(`{"key": "value"}`),
+			Tags:        pq.StringArray{"test"},
+			CreatedAt:   time.Now(),
+		}
+		err := eventRepo.Create(ctx, event)
+		require.NoError(t, err)
+		err = expander.ExpandEvents(ctx)
+		require.NoError(t, err)
+		results, err := redisClient.ZRange(ctx, namespace+ScheduleKey, 0, -1).Result()
+		require.NoError(t, err)
+		assert.NotEmpty(t, results)
+	})
+
+	t.Run("hourly frequency event expansion", func(t *testing.T) {
+		cleanup()
+		startTime := time.Now().Truncate(time.Hour)
+		scheduleConfig := &models.ScheduleConfig{
+			Frequency: "hourly",
+			Interval:  3,
+		}
+		event := &models.Event{
+			ID:          uuid.New(),
+			Name:        "Hourly Event",
+			Description: "Every 3 hours",
+			StartTime:   startTime,
+			Webhook:     "http://example.com",
+			Schedule:    scheduleConfig,
+			Status:      models.EventStatusActive,
+			Metadata:    []byte(`{"key": "value"}`),
+			Tags:        pq.StringArray{"test"},
+			CreatedAt:   time.Now(),
+		}
+		err := eventRepo.Create(ctx, event)
+		require.NoError(t, err)
+		err = expander.ExpandEvents(ctx)
+		require.NoError(t, err)
+		results, err := redisClient.ZRange(ctx, namespace+ScheduleKey, 0, -1).Result()
+		require.NoError(t, err)
+		assert.NotEmpty(t, results)
+	})
 }

internal/scheduler/schedule.go

@@ -19,12 +19,12 @@ const (
 type Frequency string
 
 const (
-	FrequencyMinute  Frequency = "minute"
-	FrequencyHour    Frequency = "hour"
-	FrequencyDaily   Frequency = "daily"
-	FrequencyWeekly  Frequency = "weekly"
-	FrequencyMonthly Frequency = "monthly"
-	FrequencyYearly  Frequency = "yearly"
+	FrequencyMinutely Frequency = "minutely"
+	FrequencyHourly   Frequency = "hourly"
+	FrequencyDaily    Frequency = "daily"
+	FrequencyWeekly   Frequency = "weekly"
+	FrequencyMonthly  Frequency = "monthly"
+	FrequencyYearly   Frequency = "yearly"
 )
 
 // DayOfWeek represents a day of the week
@@ -77,7 +77,7 @@ func ParseSchedule(scheduleStr string, logger *zap.Logger) (*Schedule, error) {
 func (s *Schedule) Validate() error {
 	// Validate frequency
 	switch s.Frequency {
-	case FrequencyMinute, FrequencyHour, FrequencyDaily, FrequencyWeekly, FrequencyMonthly, FrequencyYearly:
+	case FrequencyMinutely, FrequencyHourly, FrequencyDaily, FrequencyWeekly, FrequencyMonthly, FrequencyYearly:
 	default:
 		return fmt.Errorf("invalid frequency: %s", s.Frequency)
 	}
@@ -150,9 +150,9 @@ func (s *Schedule) GetNextOccurrences(startTime time.Time, endTime time.Time, lo
 
 		// Move to next interval
 		switch s.Frequency {
-		case FrequencyMinute:
+		case FrequencyMinutely:
 			current = current.Add(time.Duration(s.Interval) * time.Minute)
-		case FrequencyHour:
+		case FrequencyHourly:
 			current = current.Add(time.Duration(s.Interval) * time.Hour)
 		case FrequencyDaily:
 			current = current.AddDate(0, 0, s.Interval)

internal/scheduler/scheduler.go

@@ -177,9 +177,9 @@ func (s *Scheduler) calculateNextOccurrence(event *models.Event) (*time.Time, er
 	// Handle different frequencies
 	var nextTime time.Time
 	switch schedule.Frequency {
-	case "minute":
+	case "minutely":
 		nextTime = event.StartTime.Add(time.Duration(schedule.Interval) * time.Minute)
-	case "hour":
+	case "hourly":
 		nextTime = event.StartTime.Add(time.Duration(schedule.Interval) * time.Hour)
 	case "daily":
 		nextTime = event.StartTime.AddDate(0, 0, schedule.Interval)
@@ -190,30 +190,10 @@ func (s *Scheduler) calculateNextOccurrence(event *models.Event) (*time.Time, er
 	case "yearly":
 		nextTime = event.StartTime.AddDate(schedule.Interval, 0, 0)
 	default:
-		return nil, fmt.Errorf("invalid frequency: %s", schedule.Frequency)
+		return nil, fmt.Errorf("unsupported frequency: %s", schedule.Frequency)
 	}
-
-	// Check if we've exceeded count
-	if schedule.Count != nil {
-		// TODO: Implement count check
-		return nil, nil
-	}
-
-	// Check if we've exceeded until date
-	if schedule.Until != nil {
-		untilTime, err := time.Parse(time.RFC3339, *schedule.Until)
-		if err != nil {
-			return nil, fmt.Errorf("invalid until date: %w", err)
-		}
-		if nextTime.After(untilTime) {
-			return nil, nil
-		}
-	}
-
-	// Check if the next occurrence is in the past
 	if nextTime.Before(now) {
-		return nil, nil
+		nextTime = now
 	}
-
 	return &nextTime, nil
 }