schemas/graph/schema.resolvers.go

package graph

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen version v0.17.27

import (
	"context"
	"fmt"
	"strings"

	"github.com/wundergraph/graphql-go-tools/pkg/federation/sdlmerge"
	"gitlab.com/unboundsoftware/eventsourced/eventsourced"

	"gitlab.com/unboundsoftware/schemas/domain"
	"gitlab.com/unboundsoftware/schemas/graph/generated"
	"gitlab.com/unboundsoftware/schemas/graph/model"
)

// UpdateSubGraph is the resolver for the updateSubGraph field.
func (r *mutationResolver) UpdateSubGraph(ctx context.Context, input model.InputSubGraph) (*model.SubGraph, error) {
	subGraphId := r.Cache.SubGraphId(input.Ref, input.Service)
	subGraph := &domain.SubGraph{}
	if subGraphId != "" {
		subGraph.BaseAggregate = eventsourced.BaseAggregateFromString(subGraphId)
	}
	handler, err := r.handler(ctx, subGraph)
	if err != nil {
		return nil, err
	}
	if strings.TrimSpace(input.Sdl) == strings.TrimSpace(subGraph.Sdl) &&
		r.stringEqual(input.URL, subGraph.Url) &&
		r.stringEqual(input.WsURL, subGraph.WSUrl) {
		return r.toGqlSubGraph(subGraph), nil
	}
	serviceSDLs := []string{input.Sdl}
	services, _ := r.Cache.Services(input.Ref, "")
	for _, id := range services {
		sg, err := r.fetchSubGraph(ctx, id)
		if err != nil {
			return nil, err
		}
		if sg.Service != input.Service {
			serviceSDLs = append(serviceSDLs, sg.Sdl)
		}
	}
	_, err = sdlmerge.MergeSDLs(serviceSDLs...)
	if err != nil {
		return nil, err
	}
	_, err = handler.Handle(ctx, domain.UpdateSubGraph{
		Ref:       input.Ref,
		Service:   input.Service,
		Url:       input.URL,
		WSUrl:     input.WsURL,
		Sdl:       input.Sdl,
		Initiator: "Fetch name from API-key?",
	})
	if err != nil {
		return nil, err
	}
	return r.toGqlSubGraph(subGraph), nil
}

// SubGraphs is the resolver for the subGraphs field.
func (r *queryResolver) SubGraphs(ctx context.Context, ref string) ([]*model.SubGraph, error) {
	res, err := r.Supergraph(ctx, ref, nil)
	if err != nil {
		return nil, err
	}
	if s, ok := res.(*model.SubGraphs); ok {
		return s.SubGraphs, nil
	}
	return nil, fmt.Errorf("unexpected response")
}

// Supergraph is the resolver for the supergraph field.
func (r *queryResolver) Supergraph(ctx context.Context, ref string, isAfter *string) (model.Supergraph, error) {
	after := ""
	if isAfter != nil {
		after = *isAfter
	}
	services, lastUpdate := r.Cache.Services(ref, after)
	if after == lastUpdate {
		return &model.Unchanged{
			ID:              lastUpdate,
			MinDelaySeconds: 10,
		}, nil
	}
	subGraphs := make([]*model.SubGraph, len(services))
	for i, id := range services {
		sg, err := r.fetchSubGraph(ctx, id)
		if err != nil {
			return nil, err
		}
		subGraphs[i] = &model.SubGraph{
			ID:        sg.ID.String(),
			Service:   sg.Service,
			URL:       sg.Url,
			WsURL:     sg.WSUrl,
			Sdl:       sg.Sdl,
			ChangedBy: sg.ChangedBy,
			ChangedAt: sg.ChangedAt,
		}
	}
	return &model.SubGraphs{
		ID:              lastUpdate,
		SubGraphs:       subGraphs,
		MinDelaySeconds: 10,
	}, nil
}

// Mutation returns generated.MutationResolver implementation.
func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }

// Query returns generated.QueryResolver implementation.
func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }

type (
	mutationResolver struct{ *Resolver }
	queryResolver    struct{ *Resolver }
)