arp/graph/resolver.go

package graph

import (
	"sync"

	"gogs.dmsc.dev/arp/graph/model"
	"gorm.io/gorm"
)

// This file will not be regenerated automatically.
//
// It serves as dependency injection for your app, add any dependencies you require
// here.

// TaskEvent represents a task event for subscriptions
type TaskEvent struct {
	Task      *model.Task
	UserID    uint   // The user who should receive this event (assignee)
	EventType string // "created", "updated", "deleted"
}

// MessageEvent represents a message event for subscriptions
type MessageEvent struct {
	Message        *model.Message
	ChannelID      uint
	ParticipantIDs []uint // IDs of users who should receive this event
}

// Resolver is the main resolver struct
type Resolver struct {
	DB *gorm.DB

	// Pub/Sub channels for subscriptions
	taskSubscribers   map[uint]chan TaskEvent // keyed by user ID
	taskSubscribersMu sync.RWMutex

	messageSubscribers   map[uint]chan MessageEvent // keyed by user ID
	messageSubscribersMu sync.RWMutex
}

// NewResolver creates a new resolver with initialized pub/sub
func NewResolver(db *gorm.DB) *Resolver {
	return &Resolver{
		DB:                 db,
		taskSubscribers:    make(map[uint]chan TaskEvent),
		messageSubscribers: make(map[uint]chan MessageEvent),
	}
}

// SubscribeToTasks registers a user for task events and returns their event channel
func (r *Resolver) SubscribeToTasks(userID uint) <-chan TaskEvent {
	r.taskSubscribersMu.Lock()
	defer r.taskSubscribersMu.Unlock()

	ch := make(chan TaskEvent, 10)
	r.taskSubscribers[userID] = ch
	return ch
}

// PublishTaskEvent sends a task event to the assignee
func (r *Resolver) PublishTaskEvent(task *model.Task, assigneeID *uint, eventType string) {
	if assigneeID == nil {
		return // No assignee, no one to notify
	}

	event := TaskEvent{
		Task:      task,
		UserID:    *assigneeID,
		EventType: eventType,
	}

	r.taskSubscribersMu.RLock()
	defer r.taskSubscribersMu.RUnlock()

	if ch, ok := r.taskSubscribers[event.UserID]; ok {
		select {
		case ch <- event:
		default:
			// Channel full, skip event
		}
	}
}

// SubscribeToMessages registers a user for message events and returns their event channel
func (r *Resolver) SubscribeToMessages(userID uint) <-chan MessageEvent {
	r.messageSubscribersMu.Lock()
	defer r.messageSubscribersMu.Unlock()

	ch := make(chan MessageEvent, 10)
	r.messageSubscribers[userID] = ch
	return ch
}

// PublishMessageEvent sends a message event to all channel participants
func (r *Resolver) PublishMessageEvent(message *model.Message, channelID uint, participantIDs []uint) {
	event := MessageEvent{
		Message:        message,
		ChannelID:      channelID,
		ParticipantIDs: participantIDs,
	}

	r.messageSubscribersMu.RLock()
	defer r.messageSubscribersMu.RUnlock()

	for _, userID := range participantIDs {
		if ch, ok := r.messageSubscribers[userID]; ok {
			select {
			case ch <- event:
			default:
				// Channel full, skip event
			}
		}
	}
}