Moved query and mutation resolvers into individual files

graphql/resolver/queries/channel.go

@@ -0,0 +1,23 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/channel"
+)
+
+// ChannelArgs is args for channel query
+type ChannelArgs struct {
+	Name string
+}
+
+// Channel resolves the channel query
+func (r *QueryResolver) Channel(ctx context.Context, args *ChannelArgs) (*types.ChannelResolver, error) {
+	channel, err := channel.FindName(args.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.ChannelResolver{C: channel}, nil
+}

graphql/resolver/queries/channels.go

@@ -0,0 +1,28 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/channel"
+)
+
+// ChannelsArgs is args for channel query
+type ChannelsArgs struct {
+	Logged *bool
+}
+
+// Channels resolves the channels query
+func (r *QueryResolver) Channels(ctx context.Context, args *ChannelsArgs) ([]*types.ChannelResolver, error) {
+	channels, err := channel.List(args.Logged != nil && *args.Logged)
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.ChannelResolver, len(channels))
+	for i := range channels {
+		resolvers[i] = &types.ChannelResolver{C: channels[i]}
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/chapter.go

@@ -0,0 +1,23 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/story"
+)
+
+// ChapterArgs is args for chapter query
+type ChapterArgs struct {
+	ID string
+}
+
+// Chapter resolves the chapter query
+func (r *QueryResolver) Chapter(ctx context.Context, args *ChapterArgs) (*types.ChapterResolver, error) {
+	chapter, err := story.FindChapterID(args.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.ChapterResolver{C: chapter}, nil
+}

graphql/resolver/queries/character.go

@@ -0,0 +1,43 @@
+package queries
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/character"
+)
+
+// ErrIncorrectArguments is returned by character query.
+var ErrIncorrectArguments = errors.New("You can only query character by ID or Nick")
+
+// CharacterArgs is args for character query
+type CharacterArgs struct {
+	ID   *string
+	Nick *string
+}
+
+// Character resolves the character query
+func (r *QueryResolver) Character(ctx context.Context, args *CharacterArgs) (*types.CharacterResolver, error) {
+	var char character.Character
+	var err error
+
+	if args.Nick != nil && args.ID != nil {
+		return nil, ErrIncorrectArguments
+	}
+
+	switch {
+	case args.ID != nil:
+		char, err = character.FindID(*args.ID)
+	case args.Nick != nil:
+		char, err = character.FindNick(*args.Nick)
+	default:
+		err = ErrIncorrectArguments
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.CharacterResolver{C: char}, nil
+}

graphql/resolver/queries/characters.go

@@ -0,0 +1,54 @@
+package queries
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/graphql/loader"
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/character"
+)
+
+// CharactersArgs is args for characters query
+type CharactersArgs struct {
+	IDs    *[]string
+	Nicks  *[]string
+	Author *string
+}
+
+// Characters resolves the characters query
+func (r *QueryResolver) Characters(ctx context.Context, args *CharactersArgs) ([]*types.CharacterResolver, error) {
+	var chars []character.Character
+	var err error
+
+	loader := loader.FromContext(ctx)
+	if loader == nil {
+		return nil, errors.New("no loader")
+	}
+
+	switch {
+	case args.IDs != nil:
+		chars, err = character.ListIDs(*args.IDs...)
+	case args.Nicks != nil:
+		chars, err = character.ListNicks(*args.Nicks...)
+	case args.Author != nil:
+		chars, err = character.ListAuthor(*args.Author)
+	default:
+		chars, err = character.List()
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.CharacterResolver, 0, len(chars))
+	for i := range chars {
+		if chars[i].ID == "" {
+			continue
+		}
+
+		resolvers = append(resolvers, &types.CharacterResolver{C: chars[i]})
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/file.go

@@ -0,0 +1,23 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/file"
+)
+
+// FileArgs is args for file query
+type FileArgs struct {
+	ID string
+}
+
+// File resolves the file query
+func (r *QueryResolver) File(ctx context.Context, args *FileArgs) (*types.FileResolver, error) {
+	file, err := file.FindID(args.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.FileResolver{F: file}, nil
+}

graphql/resolver/queries/files.go

@@ -0,0 +1,43 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/internal/session"
+	"git.aiterp.net/rpdata/api/model/file"
+)
+
+// FilesArgs is args for files query
+type FilesArgs struct {
+	IncludePublic *bool
+	MimeTypes     *[]string
+}
+
+// Files resolves the file query
+func (r *QueryResolver) Files(ctx context.Context, args *FilesArgs) ([]*types.FileResolver, error) {
+	user := session.FromContext(ctx).User()
+	author := ""
+	if user != nil {
+		author = user.ID
+	}
+
+	public := args.IncludePublic != nil && *args.IncludePublic == true
+
+	mimeTypes := []string(nil)
+	if args.MimeTypes != nil {
+		mimeTypes = *args.MimeTypes
+	}
+
+	files, err := file.List(author, public, mimeTypes)
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.FileResolver, len(files))
+	for i := range files {
+		resolvers[i] = &types.FileResolver{F: files[i]}
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/log.go

@@ -0,0 +1,32 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/log"
+)
+
+// LogArgs is args for log query
+type LogArgs struct {
+	ID *string
+}
+
+// Log resolves the log query
+func (r *QueryResolver) Log(ctx context.Context, args *LogArgs) (*types.LogResolver, error) {
+	var l log.Log
+	var err error
+
+	switch {
+	case args.ID != nil:
+		l, err = log.FindID(*args.ID)
+	default:
+		err = ErrCannotResolve
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.LogResolver{L: l}, nil
+}

graphql/resolver/queries/logs.go

@@ -0,0 +1,79 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/log"
+)
+
+// LogsArgs is args for the logs query
+type LogsArgs struct {
+	Filter *struct {
+		Search     *string
+		Characters *[]string
+		Channels   *[]string
+		Events     *[]string
+		Open       *bool
+		Limit      *int32
+	}
+}
+
+// Logs resolves the logs query
+func (r *QueryResolver) Logs(ctx context.Context, args *LogsArgs) ([]*types.LogResolver, error) {
+	var logs []log.Log
+	var err error
+
+	filter := args.Filter
+
+	if filter != nil {
+		limit := 100
+		search := ""
+
+		if filter.Search != nil {
+			search = *filter.Search
+			limit = 0
+		}
+
+		channels := []string(nil)
+		if filter.Channels != nil {
+			channels = *filter.Channels
+			limit = 0
+		}
+
+		characters := []string(nil)
+		if filter.Characters != nil {
+			characters = *filter.Characters
+			limit = 0
+		}
+
+		events := []string(nil)
+		if filter.Events != nil {
+			events = *filter.Events
+			limit = 0
+		}
+
+		if filter.Limit != nil {
+			limit = int(*filter.Limit)
+		}
+
+		open := filter.Open != nil && *filter.Open == true
+
+		logs, err = log.ListSearch(search, channels, characters, events, open, limit)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		logs, err = log.List(100)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resolvers := make([]*types.LogResolver, len(logs))
+	for i := range logs {
+		resolvers[i] = &types.LogResolver{L: logs[i]}
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/post.go

@@ -0,0 +1,23 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/log"
+)
+
+// PostArgs is args for the post query
+type PostArgs struct {
+	ID string
+}
+
+// Post resolves the post query
+func (r *QueryResolver) Post(ctx context.Context, args *PostArgs) (*types.PostResolver, error) {
+	post, err := log.FindPostID(args.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.PostResolver{P: post}, nil
+}

graphql/resolver/queries/posts.go

@@ -0,0 +1,28 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/log"
+)
+
+// PostsArgs is args for the posts query
+type PostsArgs struct {
+	IDs []string
+}
+
+// Posts resolves the posts query
+func (r *QueryResolver) Posts(ctx context.Context, args *PostsArgs) ([]*types.PostResolver, error) {
+	posts, err := log.ListPostIDs(args.IDs...)
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.PostResolver, len(posts))
+	for i := range resolvers {
+		resolvers[i] = &types.PostResolver{P: posts[i]}
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/resolver.go

@@ -0,0 +1,11 @@
+// Package queries contains resolvers for individual GrahpQL queries. They were previously mixed in with one another, but that caused
+// difficulty seeking out specific queries.
+package queries
+
+import "errors"
+
+// QueryResolver is a resolver for all queries. The stuttery name is due to being embedded in the root resolver.
+type QueryResolver struct{}
+
+// ErrCannotResolve is returned when a resolver constructor is at its wit's end
+var ErrCannotResolve = errors.New("Cannot resolve due to invalid arguments")

graphql/resolver/queries/session.go

@@ -0,0 +1,13 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/internal/session"
+)
+
+// Session resolves query.session
+func (r *QueryResolver) Session(ctx context.Context) (*types.SessionResolver, error) {
+	return &types.SessionResolver{S: session.FromContext(ctx)}, nil
+}

graphql/resolver/queries/stories.go

@@ -0,0 +1,77 @@
+package queries
+
+import (
+	"context"
+	"time"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/story"
+)
+
+// StoriesArg is args for stories query
+type StoriesArg struct {
+	Filter *struct {
+		Author *string
+		Tags   *[]struct {
+			Kind string
+			Name string
+		}
+		EarliestFictionalDate *string
+		LatestFictionalDate   *string
+		Limit                 *int32
+	}
+}
+
+// Stories resolves the stories query
+func (r *QueryResolver) Stories(ctx context.Context, args *StoriesArg) ([]*types.StoryResolver, error) {
+	filter := args.Filter
+
+	author := ""
+	if filter != nil && filter.Author != nil {
+		author = *filter.Author
+	}
+
+	tags := make([]story.Tag, 0, 8)
+	if filter != nil && filter.Tags != nil {
+		for _, tagInput := range *filter.Tags {
+			tags = append(tags, story.Tag{
+				Kind: tagInput.Kind,
+				Name: tagInput.Name,
+			})
+		}
+	}
+
+	earliest := time.Time{}
+	err := error(nil)
+	if filter != nil && filter.EarliestFictionalDate != nil {
+		earliest, err = time.Parse(time.RFC3339Nano, *filter.EarliestFictionalDate)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	latest := time.Time{}
+	if filter != nil && filter.LatestFictionalDate != nil {
+		latest, err = time.Parse(time.RFC3339Nano, *filter.LatestFictionalDate)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	limit := 30
+	if filter != nil && filter.Limit != nil {
+		limit = int(*filter.Limit)
+	}
+
+	stories, err := story.List(author, tags, earliest, latest, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.StoryResolver, len(stories))
+	for i, story := range stories {
+		resolvers[i] = &types.StoryResolver{S: story}
+	}
+
+	return resolvers, nil
+}

graphql/resolver/queries/story.go

@@ -0,0 +1,23 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/story"
+)
+
+// StoryArgs is args for story query
+type StoryArgs struct {
+	ID string
+}
+
+// Story resolves the story query
+func (r *QueryResolver) Story(ctx context.Context, args *StoryArgs) (*types.StoryResolver, error) {
+	story, err := story.FindID(args.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.StoryResolver{S: story}, nil
+}

graphql/resolver/queries/tags.go

@@ -0,0 +1,21 @@
+package queries
+
+import (
+	"git.aiterp.net/rpdata/api/graphql/resolver/types"
+	"git.aiterp.net/rpdata/api/model/story"
+)
+
+// Tags resolves the tags query
+func (r *QueryResolver) Tags() ([]*types.TagResolver, error) {
+	tags, err := story.ListTags()
+	if err != nil {
+		return nil, err
+	}
+
+	resolvers := make([]*types.TagResolver, len(tags))
+	for i, tag := range tags {
+		resolvers[i] = &types.TagResolver{T: tag}
+	}
+
+	return resolvers, nil
+}