probo/pkg/server/api/console/v1/webhook_resolvers.go

package console_v1

// 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.93

import (
	"context"
	"errors"
	"fmt"

	"github.com/vikstrous/dataloadgen"
	"go.gearno.de/kit/log"
	"go.probo.inc/probo/pkg/coredata"
	"go.probo.inc/probo/pkg/page"
	"go.probo.inc/probo/pkg/probo"
	"go.probo.inc/probo/pkg/server/api/console/v1/dataloader"
	"go.probo.inc/probo/pkg/server/api/console/v1/schema"
	"go.probo.inc/probo/pkg/server/api/console/v1/types"
	"go.probo.inc/probo/pkg/server/gqlutils"
	"go.probo.inc/probo/pkg/validator"
)

// CreateWebhookSubscription is the resolver for the createWebhookSubscription field.
func (r *mutationResolver) CreateWebhookSubscription(ctx context.Context, input types.CreateWebhookSubscriptionInput) (*types.CreateWebhookSubscriptionPayload, error) {
	scope, err := r.authorize(ctx, input.OrganizationID, probo.ActionWebhookSubscriptionCreate)
	if err != nil {
		return nil, err
	}

	wc, err := r.probo.WebhookSubscriptions.Create(
		ctx, scope,
		probo.CreateWebhookSubscriptionRequest{
			OrganizationID: input.OrganizationID,
			EndpointURL:    input.EndpointURL,
			SelectedEvents: input.SelectedEvents,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create webhook subscription", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateWebhookSubscriptionPayload{
		WebhookSubscriptionEdge: types.NewWebhookSubscriptionEdge(wc, coredata.WebhookSubscriptionOrderFieldCreatedAt),
	}, nil
}

// UpdateWebhookSubscription is the resolver for the updateWebhookSubscription field.
func (r *mutationResolver) UpdateWebhookSubscription(ctx context.Context, input types.UpdateWebhookSubscriptionInput) (*types.UpdateWebhookSubscriptionPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionWebhookSubscriptionUpdate)
	if err != nil {
		return nil, err
	}

	wc, err := r.probo.WebhookSubscriptions.Update(
		ctx, scope,
		probo.UpdateWebhookSubscriptionRequest{
			WebhookSubscriptionID: input.ID,
			EndpointURL:           input.EndpointURL,
			SelectedEvents:        input.SelectedEvents,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update webhook subscription", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateWebhookSubscriptionPayload{
		WebhookSubscription: types.NewWebhookSubscription(wc),
	}, nil
}

// DeleteWebhookSubscription is the resolver for the deleteWebhookSubscription field.
func (r *mutationResolver) DeleteWebhookSubscription(ctx context.Context, input types.DeleteWebhookSubscriptionInput) (*types.DeleteWebhookSubscriptionPayload, error) {
	scope, err := r.authorize(ctx, input.WebhookSubscriptionID, probo.ActionWebhookSubscriptionDelete)
	if err != nil {
		return nil, err
	}

	if err := r.probo.WebhookSubscriptions.Delete(ctx, scope, input.WebhookSubscriptionID); err != nil {
		r.logger.ErrorCtx(ctx, "cannot delete webhook subscription", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteWebhookSubscriptionPayload{
		DeletedWebhookSubscriptionID: input.WebhookSubscriptionID,
	}, nil
}

// TotalCount is the resolver for the totalCount field.
func (r *webhookEventConnectionResolver) TotalCount(ctx context.Context, obj *types.WebhookEventConnection) (int, error) {
	scope, err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookSubscriptionGet)
	if err != nil {
		return 0, err
	}

	count, err := r.probo.WebhookSubscriptions.CountEventsForSubscriptionID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count webhook events", log.Error(err))
		return 0, gqlutils.Internal(ctx)
	}

	return count, nil
}

// Organization is the resolver for the organization field.
func (r *webhookSubscriptionResolver) Organization(ctx context.Context, obj *types.WebhookSubscription) (*types.Organization, error) {
	if _, err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
		return nil, err
	}

	loaders := dataloader.FromContext(ctx)

	organization, err := loaders.Organization.Load(ctx, obj.Organization.ID)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) || errors.Is(err, dataloadgen.ErrNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot load organization", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return types.NewOrganization(organization), nil
}

// SigningSecret is the resolver for the signingSecret field.
func (r *webhookSubscriptionResolver) SigningSecret(ctx context.Context, obj *types.WebhookSubscription) (string, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionWebhookSubscriptionUpdate)
	if err != nil {
		return "", err
	}

	signingSecret, err := r.probo.WebhookSubscriptions.GetSigningSecret(ctx, scope, obj.ID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot get signing secret", log.Error(err))
		return "", gqlutils.Internal(ctx)
	}

	return signingSecret, nil
}

// Events is the resolver for the events field.
func (r *webhookSubscriptionResolver) Events(ctx context.Context, obj *types.WebhookSubscription, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.WebhookEventOrderBy) (*types.WebhookEventConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionWebhookSubscriptionGet)
	if err != nil {
		return nil, err
	}

	pageOrderBy := page.OrderBy[coredata.WebhookEventOrderField]{
		Field:     coredata.WebhookEventOrderFieldCreatedAt,
		Direction: page.OrderDirectionDesc,
	}

	if orderBy != nil {
		pageOrderBy = page.OrderBy[coredata.WebhookEventOrderField]{
			Field:     orderBy.Field,
			Direction: orderBy.Direction,
		}
	}

	cursor := types.NewCursor(first, after, last, before, pageOrderBy)

	page, err := r.probo.WebhookSubscriptions.ListEventsForSubscriptionID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list webhook events", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewWebhookEventConnection(page, r, obj.ID), nil
}

// Permission is the resolver for the permission field.
func (r *webhookSubscriptionResolver) Permission(ctx context.Context, obj *types.WebhookSubscription, action string) (bool, error) {
	return r.Resolver.Permission(ctx, obj, action)
}

// TotalCount is the resolver for the totalCount field.
func (r *webhookSubscriptionConnectionResolver) TotalCount(ctx context.Context, obj *types.WebhookSubscriptionConnection) (int, error) {
	scope, err := r.authorize(ctx, obj.ParentID, probo.ActionWebhookSubscriptionList)
	if err != nil {
		return 0, err
	}

	switch obj.Resolver.(type) {
	case *organizationResolver:
		count, err := r.probo.WebhookSubscriptions.CountForOrganizationID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count webhook subscriptions", log.Error(err))
			return 0, gqlutils.Internal(ctx)
		}

		return count, nil
	}

	r.logger.ErrorCtx(ctx, "unsupported resolver for webhook subscription connection", log.String("resolver", fmt.Sprintf("%T", obj.Resolver)))

	return 0, gqlutils.Internal(ctx)
}

// WebhookEventConnection returns schema.WebhookEventConnectionResolver implementation.
func (r *Resolver) WebhookEventConnection() schema.WebhookEventConnectionResolver {
	return &webhookEventConnectionResolver{r}
}

// WebhookSubscription returns schema.WebhookSubscriptionResolver implementation.
func (r *Resolver) WebhookSubscription() schema.WebhookSubscriptionResolver {
	return &webhookSubscriptionResolver{r}
}

// WebhookSubscriptionConnection returns schema.WebhookSubscriptionConnectionResolver implementation.
func (r *Resolver) WebhookSubscriptionConnection() schema.WebhookSubscriptionConnectionResolver {
	return &webhookSubscriptionConnectionResolver{r}
}

type (
	webhookEventConnectionResolver        struct{ *Resolver }
	webhookSubscriptionResolver           struct{ *Resolver }
	webhookSubscriptionConnectionResolver struct{ *Resolver }
)