query-orchestration/internal/query/result/set/set.go

package resultset

import (
	"context"
	"database/sql"
	"errors"
	"log/slog"

	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/query/result"
	resultprocessor "queryorchestration/internal/query/result/processor"

	"github.com/google/uuid"
)

type Set struct {
	DocumentID uuid.UUID `json:"document_id" validate:"required,uuid"`
	QueryID    uuid.UUID `json:"query_id" validate:"required,uuid"`
}

func (s *Service) Set(ctx context.Context, params *Set) error {
	dbid := params.DocumentID
	textVersion, err := s.cfg.GetDBQueries().GetTextEntryByDocId(ctx, dbid)
	if err != nil {
		return err
	}

	query, err := s.svc.Query.Get(ctx, params.QueryID)
	if err != nil {
		return err
	}

	value, err := s.svc.Result.Process(ctx, &result.Process{
		DocumentID:   params.DocumentID,
		QueryID:      query.ID,
		QueryVersion: query.ActiveVersion,
	})
	if err != nil {
		return err
	}

	err = s.storeResult(ctx, textVersion, params, query.ActiveVersion, value)
	if err != nil {
		return err
	}

	slog.Debug("set query result", "query_id", params.QueryID.String(), "document_id", params.DocumentID.String())

	return s.informQueryDependents(ctx, params)
}

func (s *Service) storeResult(ctx context.Context, textVersion *repository.Currenttextentry, params *Set, activeVersion int32, value resultprocessor.Value) error {
	return s.cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, q *repository.Queries) error {
		id, err := q.AddResult(ctx, &repository.AddResultParams{
			Queryid:      params.QueryID,
			Value:        value.GetStoreValue(),
			Queryversion: activeVersion,
			Textentryid:  textVersion.ID,
		})
		if err != nil {
			return err
		}

		qResults, err := q.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
			Queryid:    &params.QueryID,
			Documentid: &params.DocumentID,
			Version:    &activeVersion,
		})
		if err != nil && !errors.Is(err, sql.ErrNoRows) {
			return err
		}

		for _, result := range qResults {
			err = q.AddResultDependency(ctx, &repository.AddResultDependencyParams{
				Resultid:         id,
				Requiredresultid: *result.ID,
			})
			if err != nil {
				return err
			}
		}

		return nil
	})
}

func (s *Service) informQueryDependents(ctx context.Context, params *Set) error {
	ids, err := s.cfg.GetDBQueries().ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
		Documentid: &params.DocumentID,
		Queryid:    &params.QueryID,
	})
	if err != nil {
		return err
	}

	return s.svc.Sync.TriggerMultiSync(ctx, params.DocumentID, ids)
}