wroofauth/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.40

import (
	"context"
	"errors"
	"fmt"
	"time"

	"git.1in9.net/raider/wroofauth/graph/model"
	"git.1in9.net/raider/wroofauth/internal/keystore"
	"git.1in9.net/raider/wroofauth/internal/logger"
	"git.1in9.net/raider/wroofauth/internal/machines/fesession"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/lestrrat-go/jwx/jwa"
	"github.com/lestrrat-go/jwx/jwt"
	redis "github.com/redis/go-redis/v9"
	"github.com/spf13/viper"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.uber.org/zap"
)

// AuthFeSessionCreate is the resolver for the authFeSessionCreate field.
func (r *mutationResolver) AuthFeSessionCreate(ctx context.Context) (*model.FeSession, error) {
	// TODO: Check auth

	feSession := fesession.NewSession(ctx, primitive.NilObjectID) // TODO: Put actual object here
	err := feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to create fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeSessionIdentify is the resolver for the authFeSessionIdentify field.
func (r *mutationResolver) AuthFeSessionIdentify(ctx context.Context, session string, identification string) (*model.FeSession, error) {
	// TODO: Check auth

	sessionId, err := primitive.ObjectIDFromHex(session)
	if err != nil {
		return nil, err
	}

	feSession, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		if err == redis.Nil {
			return nil, errors.New("session not found")
		}
		logger.Logger.Warn("failed to load fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	err = feSession.HandleIdentification(ctx, identification)
	if err != nil {
		return nil, err
	}

	err = feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to persist fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeSessionPassword is the resolver for the authFeSessionPassword field.
func (r *mutationResolver) AuthFeSessionPassword(ctx context.Context, session string, password string) (*model.FeSession, error) {
	// TODO: Check auth

	sessionId, err := primitive.ObjectIDFromHex(session)
	if err != nil {
		return nil, err
	}

	feSession, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		if err == redis.Nil {
			return nil, errors.New("session not found")
		}
		logger.Logger.Warn("failed to load fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	err = feSession.HandlePassword(ctx, password)
	if err != nil {
		return nil, err
	}

	err = feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to persist fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeSessionTotp is the resolver for the authFeSessionTOTP field.
func (r *mutationResolver) AuthFeSessionTotp(ctx context.Context, session string, totp string) (*model.FeSession, error) {
	// TODO: Check auth

	sessionId, err := primitive.ObjectIDFromHex(session)
	if err != nil {
		return nil, err
	}

	feSession, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		if err == redis.Nil {
			return nil, errors.New("session not found")
		}
		logger.Logger.Warn("failed to load fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	err = feSession.HandleTOTP(ctx, totp)
	if err != nil {
		return nil, err
	}

	err = feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to persist fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeSessionLock is the resolver for the authFeSessionLock field.
func (r *mutationResolver) AuthFeSessionLock(ctx context.Context, session string) (*model.FeSession, error) {
	// TODO: Check auth

	sessionId, err := primitive.ObjectIDFromHex(session)
	if err != nil {
		return nil, err
	}

	feSession, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		if err == redis.Nil {
			return nil, errors.New("session not found")
		}
		logger.Logger.Warn("failed to load fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	err = feSession.HandleLock(ctx)
	if err != nil {
		return nil, err
	}

	err = feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to persist fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeSessionLogout is the resolver for the authFeSessionLogout field.
func (r *mutationResolver) AuthFeSessionLogout(ctx context.Context, session string) (*model.FeSession, error) {
	// TODO: Check auth

	sessionId, err := primitive.ObjectIDFromHex(session)
	if err != nil {
		return nil, err
	}

	feSession, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		if err == redis.Nil {
			return nil, errors.New("session not found")
		}
		logger.Logger.Warn("failed to load fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	err = feSession.HandleLogout(ctx)
	if err != nil {
		return nil, err
	}

	err = feSession.Persist(ctx)
	if err != nil {
		logger.Logger.Warn("failed to persist fesession", zap.Error(err), zap.String("request-id", middleware.GetReqID(ctx)))
		return nil, errors.New("internal server error")
	}

	modSession := model.FeSessionFromDb(*feSession)
	return &modSession, nil
}

// AuthFeTokenCreate is the resolver for the authFeTokenCreate field.
func (r *mutationResolver) AuthFeTokenCreate(ctx context.Context) (string, error) {
	id := primitive.NewObjectID()

	t := jwt.NewBuilder()
	t.Issuer(viper.GetString("wroofauth.url"))
	t.IssuedAt(time.Now())
	t.Audience([]string{
		viper.GetString("wroofauth.url"),
	})
	t.Claim("is_frontend_token", true)
	t.JwtID(id.Hex())

	token, err := t.Build()
	if err != nil {
		return "", err
	}

	kid := viper.GetString("crypto.use_key.frontend")

	key, found := keystore.Global.LookupKeyID(kid)
	if !found {
		logger.Logger.Error("Keystore doesn't contain key to use for frontend!")
		return "", errors.New("misconfigured server")
	}

	signed, err := jwt.Sign(token, jwa.EdDSA, key)
	if err != nil {
		return "", err
	}

	return string(signed), nil
}

// Self is the resolver for the self field.
func (r *queryResolver) Self(ctx context.Context) (model.Actor, error) {
	panic(fmt.Errorf("not implemented: Self - self"))
}

// User is the resolver for the user field.
func (r *queryResolver) User(ctx context.Context, id string) (*model.User, error) {
	panic(fmt.Errorf("not implemented: User - user"))
}

// AuthFeSession is the resolver for the authFeSession field.
func (r *queryResolver) AuthFeSession(ctx context.Context, id string) (*model.FeSession, error) {
	sessionId, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return nil, err
	}

	session, err := fesession.GetById(ctx, sessionId)
	if err != nil {
		return nil, err
	}

	obj := model.FeSessionFromDb(*session)

	return &obj, nil
}

// Node is the resolver for the node field.
func (r *queryResolver) Node(ctx context.Context, id string) (model.Node, error) {
	panic(fmt.Errorf("not implemented: Node - node"))
}

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

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

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