query-orchestration/api/controllers/query.go

package controllers

import (
	"context"
	"queryorchestration/api/grpc/spec"
	serviceinterfaces "queryorchestration/api/serviceInterfaces"
	"queryorchestration/internal/query"
	queryprocessor "queryorchestration/internal/queryProcessor"

	"github.com/go-playground/validator/v10"
	"github.com/google/uuid"

	"google.golang.org/protobuf/types/known/emptypb"
)

type QueryController struct {
	serviceinterfaces.UnimplementedQueryServiceServer
	query     query.Service
	validator *validator.Validate
}

func NewQueryController(querySvc query.Service, validator *validator.Validate) *QueryController {
	return &QueryController{
		query:     querySvc,
		validator: validator,
	}
}

func (s *QueryController) List(ctx context.Context, req *serviceinterfaces.QueryFilter) (*serviceinterfaces.Queries, error) {
	types := make([]queryprocessor.Type, len(req.GetTypes()))
	for index, t := range req.GetTypes() {
		types[index] = queryprocessor.Type(ParseSpecQueryType(t))
	}

	filters := query.ListFilters{
		Types: types,
	}

	queries, err := s.query.List(ctx, filters)
	if err != nil {
		return nil, err
	}

	outQueries := make([]*serviceinterfaces.Query, len(*queries))
	for index, query := range *queries {
		outQueries[index] = ParseQuery(&query)
	}

	return &serviceinterfaces.Queries{
		Queries: outQueries,
	}, nil
}

func (s *QueryController) Get(ctx context.Context, req *serviceinterfaces.IdMessage) (*serviceinterfaces.Query, error) {
	id, err := uuid.Parse(req.GetId())
	if err != nil {
		return nil, err
	}

	query, err := s.query.Get(ctx, id)
	if err != nil {
		return nil, err
	}

	return ParseQuery(query), nil
}

func (s *QueryController) Create(ctx context.Context, req *serviceinterfaces.QueryCreate) (*serviceinterfaces.IdMessage, error) {
	requiredQueryIDs := make([]uuid.UUID, len(req.GetRequiredQueries()))
	for index, id := range req.GetRequiredQueries() {
		parsedID, err := uuid.Parse(id)
		if err != nil {
			return nil, err
		}

		requiredQueryIDs[index] = parsedID
	}

	id, err := s.query.Create(ctx, &queryprocessor.Create{
		Type:             ParseSpecQueryType(req.GetType()),
		RequiredQueryIDs: requiredQueryIDs,
	})
	if err != nil {
		return nil, err
	}

	return &serviceinterfaces.IdMessage{
		Id: id.String(),
	}, nil
}

func (s *QueryController) Update(ctx context.Context, req *serviceinterfaces.QueryUpdate) (*emptypb.Empty, error) {
	id, err := uuid.Parse(req.GetId())
	if err != nil {
		return nil, err
	}

	err = s.query.Update(ctx, &queryprocessor.Update{
		ID: id,
	})
	if err != nil {
		return nil, err
	}

	return &emptypb.Empty{}, nil
}

func (s *QueryController) Deprecate(ctx context.Context, req *spec.IdMessage) (*emptypb.Empty, error) {
	id, err := uuid.Parse(req.GetId())
	if err != nil {
		return nil, err
	}

	err = s.query.Deprecate(ctx, id)
	if err != nil {
		return nil, err
	}

	return &emptypb.Empty{}, nil
}

func (s *QueryController) Test(ctx context.Context, req *serviceinterfaces.QueryTestRequest) (*serviceinterfaces.QueryTestResponse, error) {
	queryId, err := uuid.Parse(req.GetQueryId())
	if err != nil {
		return nil, err
	}
	docId, err := uuid.Parse(req.GetDocumentId())
	if err != nil {
		return nil, err
	}

	value, err := s.query.Test(ctx, query.Test{
		QueryID:      queryId,
		QueryVersion: req.GetQueryVersion(),
		DocumentID:   docId,
	})
	if err != nil {
		return nil, err
	}

	return &serviceinterfaces.QueryTestResponse{
		Value: value,
	}, nil
}