probo/pkg/server/api/console/v1/risk_assessment_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.94

import (
	"context"
	"errors"

	"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/riskmanagement"
	"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"
)

// CreateRiskAssessment is the resolver for the createRiskAssessment field.
func (r *mutationResolver) CreateRiskAssessment(ctx context.Context, input types.CreateRiskAssessmentInput) (*types.CreateRiskAssessmentPayload, error) {
	scope, err := r.authorize(ctx, input.OrganizationID, probo.ActionRiskAssessmentCreate)
	if err != nil {
		return nil, err
	}

	ra, err := r.riskManagement.Create(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentRequest{
			OrganizationID: input.OrganizationID,
			Name:           input.Name,
			Description:    input.Description,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk assessment", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentPayload{
		RiskAssessmentEdge: types.NewRiskAssessmentConnectionEdge(ra, coredata.RiskAssessmentOrderFieldCreatedAt),
	}, nil
}

// UpdateRiskAssessment is the resolver for the updateRiskAssessment field.
func (r *mutationResolver) UpdateRiskAssessment(ctx context.Context, input types.UpdateRiskAssessmentInput) (*types.UpdateRiskAssessmentPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentUpdate)
	if err != nil {
		return nil, err
	}

	ra, err := r.riskManagement.Update(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentRequest{
			ID:          input.ID,
			Name:        input.Name,
			Description: gqlutils.UnwrapOmittable(input.Description),
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk assessment", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentPayload{RiskAssessment: types.NewRiskAssessment(ra)}, nil
}

// DeleteRiskAssessment is the resolver for the deleteRiskAssessment field.
func (r *mutationResolver) DeleteRiskAssessment(ctx context.Context, input types.DeleteRiskAssessmentInput) (*types.DeleteRiskAssessmentPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.Delete(ctx, scope, input.RiskAssessmentID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk assessment", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentPayload{DeletedRiskAssessmentID: input.RiskAssessmentID}, nil
}

// CreateRiskAssessmentScope is the resolver for the createRiskAssessmentScope field.
func (r *mutationResolver) CreateRiskAssessmentScope(ctx context.Context, input types.CreateRiskAssessmentScopeInput) (*types.CreateRiskAssessmentScopePayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentScopeCreate)
	if err != nil {
		return nil, err
	}

	raScope, err := r.riskManagement.CreateScope(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentScopeRequest{
			RiskAssessmentID: input.RiskAssessmentID,
			Name:             input.Name,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk assessment scope", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentScopePayload{
		RiskAssessmentScopeEdge: types.NewRiskAssessmentScopeConnectionEdge(raScope, coredata.RiskAssessmentScopeOrderFieldCreatedAt),
	}, nil
}

// UpdateRiskAssessmentScope is the resolver for the updateRiskAssessmentScope field.
func (r *mutationResolver) UpdateRiskAssessmentScope(ctx context.Context, input types.UpdateRiskAssessmentScopeInput) (*types.UpdateRiskAssessmentScopePayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScopeUpdate)
	if err != nil {
		return nil, err
	}

	raScope, err := r.riskManagement.UpdateScope(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentScopeRequest{
			ID:   input.ID,
			Name: input.Name,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk assessment scope", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentScopePayload{RiskAssessmentScope: types.NewRiskAssessmentScope(raScope)}, nil
}

// DeleteRiskAssessmentScope is the resolver for the deleteRiskAssessmentScope field.
func (r *mutationResolver) DeleteRiskAssessmentScope(ctx context.Context, input types.DeleteRiskAssessmentScopeInput) (*types.DeleteRiskAssessmentScopePayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteScope(ctx, scope, input.RiskAssessmentScopeID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk assessment scope", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentScopePayload{DeletedRiskAssessmentScopeID: input.RiskAssessmentScopeID}, nil
}

// CreateRiskAssessmentNode is the resolver for the createRiskAssessmentNode field.
func (r *mutationResolver) CreateRiskAssessmentNode(ctx context.Context, input types.CreateRiskAssessmentNodeInput) (*types.CreateRiskAssessmentNodePayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentNodeCreate)
	if err != nil {
		return nil, err
	}

	node, err := r.riskManagement.CreateNode(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentNodeRequest{
			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
			BoundaryID:            input.BoundaryID,
			NodeType:              input.NodeType,
			Name:                  input.Name,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk assessment node", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentNodePayload{
		RiskAssessmentNodeEdge: &types.RiskAssessmentNodeConnectionEdge{
			Cursor: node.CursorKey(coredata.RiskAssessmentNodeOrderFieldCreatedAt),
			Node:   types.NewRiskAssessmentNode(node),
		},
	}, nil
}

// UpdateRiskAssessmentNode is the resolver for the updateRiskAssessmentNode field.
func (r *mutationResolver) UpdateRiskAssessmentNode(ctx context.Context, input types.UpdateRiskAssessmentNodeInput) (*types.UpdateRiskAssessmentNodePayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentNodeUpdate)
	if err != nil {
		return nil, err
	}

	node, err := r.riskManagement.UpdateNode(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentNodeRequest{
			ID:         input.ID,
			BoundaryID: gqlutils.UnwrapOmittable(input.BoundaryID),
			NodeType:   input.NodeType,
			Name:       input.Name,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk assessment node", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentNodePayload{RiskAssessmentNode: types.NewRiskAssessmentNode(node)}, nil
}

// DeleteRiskAssessmentNode is the resolver for the deleteRiskAssessmentNode field.
func (r *mutationResolver) DeleteRiskAssessmentNode(ctx context.Context, input types.DeleteRiskAssessmentNodeInput) (*types.DeleteRiskAssessmentNodePayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentNodeID, probo.ActionRiskAssessmentNodeDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteNode(ctx, scope, input.RiskAssessmentNodeID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk assessment node", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentNodePayload{DeletedRiskAssessmentNodeID: input.RiskAssessmentNodeID}, nil
}

// CreateRiskAssessmentBoundary is the resolver for the createRiskAssessmentBoundary field.
func (r *mutationResolver) CreateRiskAssessmentBoundary(ctx context.Context, input types.CreateRiskAssessmentBoundaryInput) (*types.CreateRiskAssessmentBoundaryPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentBoundaryCreate)
	if err != nil {
		return nil, err
	}

	boundary, err := r.riskManagement.CreateBoundary(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentBoundaryRequest{
			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
			ParentBoundaryID:      input.ParentBoundaryID,
			Name:                  input.Name,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk assessment boundary", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentBoundaryPayload{
		RiskAssessmentBoundaryEdge: &types.RiskAssessmentBoundaryConnectionEdge{
			Cursor: boundary.CursorKey(coredata.RiskAssessmentBoundaryOrderFieldCreatedAt),
			Node:   types.NewRiskAssessmentBoundary(boundary),
		},
	}, nil
}

// UpdateRiskAssessmentBoundary is the resolver for the updateRiskAssessmentBoundary field.
func (r *mutationResolver) UpdateRiskAssessmentBoundary(ctx context.Context, input types.UpdateRiskAssessmentBoundaryInput) (*types.UpdateRiskAssessmentBoundaryPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentBoundaryUpdate)
	if err != nil {
		return nil, err
	}

	boundary, err := r.riskManagement.UpdateBoundary(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentBoundaryRequest{
			ID:               input.ID,
			ParentBoundaryID: gqlutils.UnwrapOmittable(input.ParentBoundaryID),
			Name:             input.Name,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk assessment boundary", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentBoundaryPayload{RiskAssessmentBoundary: types.NewRiskAssessmentBoundary(boundary)}, nil
}

// DeleteRiskAssessmentBoundary is the resolver for the deleteRiskAssessmentBoundary field.
func (r *mutationResolver) DeleteRiskAssessmentBoundary(ctx context.Context, input types.DeleteRiskAssessmentBoundaryInput) (*types.DeleteRiskAssessmentBoundaryPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentBoundaryID, probo.ActionRiskAssessmentBoundaryDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteBoundary(ctx, scope, input.RiskAssessmentBoundaryID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk assessment boundary", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentBoundaryPayload{DeletedRiskAssessmentBoundaryID: input.RiskAssessmentBoundaryID}, nil
}

// CreateRiskAssessmentProcess is the resolver for the createRiskAssessmentProcess field.
func (r *mutationResolver) CreateRiskAssessmentProcess(ctx context.Context, input types.CreateRiskAssessmentProcessInput) (*types.CreateRiskAssessmentProcessPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentProcessCreate)
	if err != nil {
		return nil, err
	}

	process, err := r.riskManagement.CreateProcess(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentProcessRequest{
			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
			SourceNodeID:          input.SourceNodeID,
			TargetNodeID:          input.TargetNodeID,
			Name:                  input.Name,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk assessment process", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentProcessPayload{
		RiskAssessmentProcessEdge: &types.RiskAssessmentProcessConnectionEdge{
			Cursor: process.CursorKey(coredata.RiskAssessmentProcessOrderFieldCreatedAt),
			Node:   types.NewRiskAssessmentProcess(process),
		},
	}, nil
}

// UpdateRiskAssessmentProcess is the resolver for the updateRiskAssessmentProcess field.
func (r *mutationResolver) UpdateRiskAssessmentProcess(ctx context.Context, input types.UpdateRiskAssessmentProcessInput) (*types.UpdateRiskAssessmentProcessPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentProcessUpdate)
	if err != nil {
		return nil, err
	}

	process, err := r.riskManagement.UpdateProcess(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentProcessRequest{
			ID:           input.ID,
			SourceNodeID: input.SourceNodeID,
			TargetNodeID: input.TargetNodeID,
			Name:         input.Name,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk assessment process", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentProcessPayload{RiskAssessmentProcess: types.NewRiskAssessmentProcess(process)}, nil
}

// DeleteRiskAssessmentProcess is the resolver for the deleteRiskAssessmentProcess field.
func (r *mutationResolver) DeleteRiskAssessmentProcess(ctx context.Context, input types.DeleteRiskAssessmentProcessInput) (*types.DeleteRiskAssessmentProcessPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentProcessID, probo.ActionRiskAssessmentProcessDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteProcess(ctx, scope, input.RiskAssessmentProcessID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk assessment process", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentProcessPayload{DeletedRiskAssessmentProcessID: input.RiskAssessmentProcessID}, nil
}

// CreateRiskAssessmentThreat is the resolver for the createRiskAssessmentThreat field.
func (r *mutationResolver) CreateRiskAssessmentThreat(ctx context.Context, input types.CreateRiskAssessmentThreatInput) (*types.CreateRiskAssessmentThreatPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentThreatCreate)
	if err != nil {
		return nil, err
	}

	threat, err := r.riskManagement.CreateThreat(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentThreatRequest{
			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
			ProcessID:             input.ProcessID,
			Name:                  input.Name,
			Category:              input.Category,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk threat", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentThreatPayload{
		RiskAssessmentThreatEdge: &types.RiskAssessmentThreatConnectionEdge{
			Cursor: threat.CursorKey(coredata.RiskAssessmentThreatOrderFieldCreatedAt),
			Node:   types.NewRiskAssessmentThreat(threat),
		},
	}, nil
}

// UpdateRiskAssessmentThreat is the resolver for the updateRiskAssessmentThreat field.
func (r *mutationResolver) UpdateRiskAssessmentThreat(ctx context.Context, input types.UpdateRiskAssessmentThreatInput) (*types.UpdateRiskAssessmentThreatPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentThreatUpdate)
	if err != nil {
		return nil, err
	}

	threat, err := r.riskManagement.UpdateThreat(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentThreatRequest{
			ID:        input.ID,
			ProcessID: input.ProcessID,
			Name:      input.Name,
			Category:  input.Category,
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk threat", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentThreatPayload{RiskAssessmentThreat: types.NewRiskAssessmentThreat(threat)}, nil
}

// DeleteRiskAssessmentThreat is the resolver for the deleteRiskAssessmentThreat field.
func (r *mutationResolver) DeleteRiskAssessmentThreat(ctx context.Context, input types.DeleteRiskAssessmentThreatInput) (*types.DeleteRiskAssessmentThreatPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentThreatID, probo.ActionRiskAssessmentThreatDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteThreat(ctx, scope, input.RiskAssessmentThreatID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk threat", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentThreatPayload{DeletedRiskAssessmentThreatID: input.RiskAssessmentThreatID}, nil
}

// CreateRiskAssessmentScenario is the resolver for the createRiskAssessmentScenario field.
func (r *mutationResolver) CreateRiskAssessmentScenario(ctx context.Context, input types.CreateRiskAssessmentScenarioInput) (*types.CreateRiskAssessmentScenarioPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScenarioCreate)
	if err != nil {
		return nil, err
	}

	scenario, err := r.riskManagement.CreateScenario(
		ctx,
		scope,
		riskmanagement.CreateRiskAssessmentScenarioRequest{
			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
			Name:                  input.Name,
			Description:           input.Description,
		},
	)
	if err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot create risk scenario", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.CreateRiskAssessmentScenarioPayload{
		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
			Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
			Node:   types.NewRiskAssessmentScenario(scenario),
		},
	}, nil
}

// UpdateRiskAssessmentScenario is the resolver for the updateRiskAssessmentScenario field.
func (r *mutationResolver) UpdateRiskAssessmentScenario(ctx context.Context, input types.UpdateRiskAssessmentScenarioInput) (*types.UpdateRiskAssessmentScenarioPayload, error) {
	scope, err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScenarioUpdate)
	if err != nil {
		return nil, err
	}

	scenario, err := r.riskManagement.UpdateScenario(
		ctx,
		scope,
		riskmanagement.UpdateRiskAssessmentScenarioRequest{
			ID:          input.ID,
			Name:        input.Name,
			Description: gqlutils.UnwrapOmittable(input.Description),
		},
	)
	if err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot update risk scenario", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.UpdateRiskAssessmentScenarioPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
}

// DeleteRiskAssessmentScenario is the resolver for the deleteRiskAssessmentScenario field.
func (r *mutationResolver) DeleteRiskAssessmentScenario(ctx context.Context, input types.DeleteRiskAssessmentScenarioInput) (*types.DeleteRiskAssessmentScenarioPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioDelete)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.DeleteScenario(ctx, scope, input.RiskAssessmentScenarioID); err != nil {
		if errors.Is(err, coredata.ErrResourceNotFound) {
			return nil, gqlutils.NotFound(ctx, err)
		}

		r.logger.ErrorCtx(ctx, "cannot delete risk scenario", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return &types.DeleteRiskAssessmentScenarioPayload{DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID}, nil
}

// LinkRiskAssessmentScenarioThreat is the resolver for the linkRiskAssessmentScenarioThreat field.
func (r *mutationResolver) LinkRiskAssessmentScenarioThreat(ctx context.Context, input types.LinkRiskAssessmentScenarioThreatInput) (*types.LinkRiskAssessmentScenarioThreatPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatLink)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.LinkScenarioThreat(
		ctx,
		scope,
		riskmanagement.LinkRiskAssessmentScenarioThreatRequest{
			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
			ThreatID:                 input.ThreatID,
		},
	); err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot link risk scenario threat", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.LinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
}

// UnlinkRiskAssessmentScenarioThreat is the resolver for the unlinkRiskAssessmentScenarioThreat field.
func (r *mutationResolver) UnlinkRiskAssessmentScenarioThreat(ctx context.Context, input types.UnlinkRiskAssessmentScenarioThreatInput) (*types.UnlinkRiskAssessmentScenarioThreatPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatUnlink)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.UnlinkScenarioThreat(
		ctx,
		scope,
		riskmanagement.UnlinkRiskAssessmentScenarioThreatRequest{
			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
			ThreatID:                 input.ThreatID,
		},
	); err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario threat", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.UnlinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
}

// LinkRiskAssessmentScenarioRisk is the resolver for the linkRiskAssessmentScenarioRisk field.
func (r *mutationResolver) LinkRiskAssessmentScenarioRisk(ctx context.Context, input types.LinkRiskAssessmentScenarioRiskInput) (*types.LinkRiskAssessmentScenarioRiskPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskLink)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.LinkScenarioRisk(
		ctx,
		scope,
		riskmanagement.LinkRiskAssessmentScenarioRiskRequest{
			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
			RiskID:                   input.RiskID,
		},
	); err != nil {
		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
			return nil, gqlutils.Conflict(ctx, err)
		}

		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot link risk scenario risk", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	s := types.NewRiskAssessmentScenario(scenario)

	return &types.LinkRiskAssessmentScenarioRiskPayload{
		RiskAssessmentScenario: s,
		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
			Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
			Node:   s,
		},
	}, nil
}

// UnlinkRiskAssessmentScenarioRisk is the resolver for the unlinkRiskAssessmentScenarioRisk field.
func (r *mutationResolver) UnlinkRiskAssessmentScenarioRisk(ctx context.Context, input types.UnlinkRiskAssessmentScenarioRiskInput) (*types.UnlinkRiskAssessmentScenarioRiskPayload, error) {
	scope, err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskUnlink)
	if err != nil {
		return nil, err
	}

	if err := r.riskManagement.UnlinkScenarioRisk(
		ctx,
		scope,
		riskmanagement.UnlinkRiskAssessmentScenarioRiskRequest{
			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
			RiskID:                   input.RiskID,
		},
	); err != nil {
		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
		}

		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario risk", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &types.UnlinkRiskAssessmentScenarioRiskPayload{
		RiskAssessmentScenario:          types.NewRiskAssessmentScenario(scenario),
		DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
	}, nil
}

// Organization is the resolver for the organization field.
func (r *riskAssessmentResolver) Organization(ctx context.Context, obj *types.RiskAssessment) (*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 get organization", log.Error(err))

		return nil, gqlutils.Internal(ctx)
	}

	return types.NewOrganization(organization), nil
}

// Scopes is the resolver for the scopes field.
func (r *riskAssessmentResolver) Scopes(ctx context.Context, obj *types.RiskAssessment, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScopeOrderBy) (*types.RiskAssessmentScopeConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListScopesForRiskAssessmentID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk assessment scopes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentScopeConnection(p, r, obj.ID), nil
}

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

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

	count, err := r.riskManagement.CountBoundariesForScopeID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count risk assessment boundaries", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &count, nil
}

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

	count, err := r.riskManagement.CountForOrganizationID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count risk assessments", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &count, nil
}

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

	count, err := r.riskManagement.CountNodesForScopeID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count risk assessment nodes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &count, nil
}

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

	count, err := r.riskManagement.CountProcessesForScopeID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count risk assessment processes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &count, nil
}

// Scope is the resolver for the scope field.
func (r *riskAssessmentScenarioResolver) Scope(ctx context.Context, obj *types.RiskAssessmentScenario) (*types.RiskAssessmentScope, error) {
	scope, err := r.authorize(ctx, obj.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeGet)
	if err != nil {
		return nil, err
	}

	raScope, err := r.riskManagement.GetScope(ctx, scope, obj.RiskAssessmentScopeID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot load risk assessment scope", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentScope(raScope), nil
}

// Threats is the resolver for the threats field.
func (r *riskAssessmentScenarioResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListThreatsForScenarioID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list scenario threats", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
}

// Risks is the resolver for the risks field.
func (r *riskAssessmentScenarioResolver) Risks(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskOrderBy) (*types.RiskConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListRisksForScenarioID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list scenario risks", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskConnection(p, r, obj.ID, nil), nil
}

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

	switch obj.Resolver.(type) {
	case *riskAssessmentScopeResolver:
		count, err := r.riskManagement.CountScenariosForScopeID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	case *organizationResolver:
		count, err := r.riskManagement.CountScenariosForOrganizationID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	default:
		count, err := r.riskManagement.CountScenariosForRiskID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	}
}

// Nodes is the resolver for the nodes field.
func (r *riskAssessmentScopeResolver) Nodes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentNodeOrderBy) (*types.RiskAssessmentNodeConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentNodeList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListNodesForScopeID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk assessment nodes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentNodeConnection(p, r, obj.ID), nil
}

// Boundaries is the resolver for the boundaries field.
func (r *riskAssessmentScopeResolver) Boundaries(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentBoundaryOrderBy) (*types.RiskAssessmentBoundaryConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentBoundaryList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListBoundariesForScopeID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk assessment boundaries", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentBoundaryConnection(p, r, obj.ID), nil
}

// Processes is the resolver for the processes field.
func (r *riskAssessmentScopeResolver) Processes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentProcessOrderBy) (*types.RiskAssessmentProcessConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentProcessList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListProcessesForScopeID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk assessment processes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentProcessConnection(p, r, obj.ID), nil
}

// Threats is the resolver for the threats field.
func (r *riskAssessmentScopeResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListThreatsForScopeID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk threats", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
}

// Scenarios is the resolver for the scenarios field.
func (r *riskAssessmentScopeResolver) Scenarios(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScenarioOrderBy) (*types.RiskAssessmentScenarioConnection, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList)
	if err != nil {
		return nil, err
	}

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

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

	p, err := r.riskManagement.ListScenariosForScopeID(ctx, scope, obj.ID, cursor)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
}

// MermaidChart is the resolver for the mermaidChart field.
func (r *riskAssessmentScopeResolver) MermaidChart(ctx context.Context, obj *types.RiskAssessmentScope) (string, error) {
	scope, err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeGet)
	if err != nil {
		return "", err
	}

	chart, err := r.riskManagement.BuildScopeMermaidChart(ctx, scope, obj.ID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot build risk assessment scope mermaid chart", log.Error(err))
		return "", gqlutils.Internal(ctx)
	}

	return chart, nil
}

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

	count, err := r.riskManagement.CountScopesForRiskAssessmentID(ctx, scope, obj.ParentID)
	if err != nil {
		r.logger.ErrorCtx(ctx, "cannot count risk assessment scopes", log.Error(err))
		return nil, gqlutils.Internal(ctx)
	}

	return &count, nil
}

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

	switch obj.Resolver.(type) {
	case *riskAssessmentScenarioResolver:
		count, err := r.riskManagement.CountThreatsForScenarioID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count scenario threats", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	default:
		count, err := r.riskManagement.CountThreatsForScopeID(ctx, scope, obj.ParentID)
		if err != nil {
			r.logger.ErrorCtx(ctx, "cannot count risk threats", log.Error(err))
			return nil, gqlutils.Internal(ctx)
		}

		return &count, nil
	}
}

// RiskAssessment returns schema.RiskAssessmentResolver implementation.
func (r *Resolver) RiskAssessment() schema.RiskAssessmentResolver { return &riskAssessmentResolver{r} }

// RiskAssessmentBoundaryConnection returns schema.RiskAssessmentBoundaryConnectionResolver implementation.
func (r *Resolver) RiskAssessmentBoundaryConnection() schema.RiskAssessmentBoundaryConnectionResolver {
	return &riskAssessmentBoundaryConnectionResolver{r}
}

// RiskAssessmentConnection returns schema.RiskAssessmentConnectionResolver implementation.
func (r *Resolver) RiskAssessmentConnection() schema.RiskAssessmentConnectionResolver {
	return &riskAssessmentConnectionResolver{r}
}

// RiskAssessmentNodeConnection returns schema.RiskAssessmentNodeConnectionResolver implementation.
func (r *Resolver) RiskAssessmentNodeConnection() schema.RiskAssessmentNodeConnectionResolver {
	return &riskAssessmentNodeConnectionResolver{r}
}

// RiskAssessmentProcessConnection returns schema.RiskAssessmentProcessConnectionResolver implementation.
func (r *Resolver) RiskAssessmentProcessConnection() schema.RiskAssessmentProcessConnectionResolver {
	return &riskAssessmentProcessConnectionResolver{r}
}

// RiskAssessmentScenario returns schema.RiskAssessmentScenarioResolver implementation.
func (r *Resolver) RiskAssessmentScenario() schema.RiskAssessmentScenarioResolver {
	return &riskAssessmentScenarioResolver{r}
}

// RiskAssessmentScenarioConnection returns schema.RiskAssessmentScenarioConnectionResolver implementation.
func (r *Resolver) RiskAssessmentScenarioConnection() schema.RiskAssessmentScenarioConnectionResolver {
	return &riskAssessmentScenarioConnectionResolver{r}
}

// RiskAssessmentScope returns schema.RiskAssessmentScopeResolver implementation.
func (r *Resolver) RiskAssessmentScope() schema.RiskAssessmentScopeResolver {
	return &riskAssessmentScopeResolver{r}
}

// RiskAssessmentScopeConnection returns schema.RiskAssessmentScopeConnectionResolver implementation.
func (r *Resolver) RiskAssessmentScopeConnection() schema.RiskAssessmentScopeConnectionResolver {
	return &riskAssessmentScopeConnectionResolver{r}
}

// RiskAssessmentThreatConnection returns schema.RiskAssessmentThreatConnectionResolver implementation.
func (r *Resolver) RiskAssessmentThreatConnection() schema.RiskAssessmentThreatConnectionResolver {
	return &riskAssessmentThreatConnectionResolver{r}
}

type (
	riskAssessmentResolver                   struct{ *Resolver }
	riskAssessmentBoundaryConnectionResolver struct{ *Resolver }
	riskAssessmentConnectionResolver         struct{ *Resolver }
	riskAssessmentNodeConnectionResolver     struct{ *Resolver }
	riskAssessmentProcessConnectionResolver  struct{ *Resolver }
	riskAssessmentScenarioResolver           struct{ *Resolver }
	riskAssessmentScenarioConnectionResolver struct{ *Resolver }
	riskAssessmentScopeResolver              struct{ *Resolver }
	riskAssessmentScopeConnectionResolver    struct{ *Resolver }
	riskAssessmentThreatConnectionResolver   struct{ *Resolver }
)