Merge remote-tracking branch 'origin/master' into cheshirekow-jira

3 files changed, 399 insertions, 18 deletions

diff --git a/graphql/models/gen_models.go b/graphql/models/gen_models.go
index 5498960b..b3e14655 100644
--- a/graphql/models/gen_models.go
+++ b/graphql/models/gen_models.go
@@ -8,7 +8,6 @@ import (
 	"strconv"
 
 	"github.com/MichaelMure/git-bug/bug"
-	"github.com/MichaelMure/git-bug/identity"
 	"github.com/MichaelMure/git-bug/util/git"
 )
 
@@ -34,7 +33,7 @@ type AddCommentPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
 	Operation *bug.AddCommentOperation `json:"operation"`
 }
@@ -42,8 +41,8 @@ type AddCommentPayload struct {
 // The connection type for Bug.
 type BugConnection struct {
 	// A list of edges.
-	Edges []*BugEdge      `json:"edges"`
-	Nodes []*bug.Snapshot `json:"nodes"`
+	Edges []*BugEdge   `json:"edges"`
+	Nodes []BugWrapper `json:"nodes"`
 	// Information to aid in pagination.
 	PageInfo *PageInfo `json:"pageInfo"`
 	// Identifies the total count of items in the connection.
@@ -55,7 +54,7 @@ type BugEdge struct {
 	// A cursor for use in pagination.
 	Cursor string `json:"cursor"`
 	// The item at the end of the edge.
-	Node *bug.Snapshot `json:"node"`
+	Node BugWrapper `json:"node"`
 }
 
 type ChangeLabelInput struct {
@@ -75,7 +74,7 @@ type ChangeLabelPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
 	Operation *bug.LabelChangeOperation `json:"operation"`
 	// The effect each source label had.
@@ -95,7 +94,7 @@ type CloseBugPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
 	Operation *bug.SetStatusOperation `json:"operation"`
 }
@@ -125,7 +124,7 @@ type CommitAsNeededPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 }
 
 type CommitInput struct {
@@ -141,19 +140,19 @@ type CommitPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 }
 
 type IdentityConnection struct {
-	Edges      []*IdentityEdge      `json:"edges"`
-	Nodes      []identity.Interface `json:"nodes"`
-	PageInfo   *PageInfo            `json:"pageInfo"`
-	TotalCount int                  `json:"totalCount"`
+	Edges      []*IdentityEdge   `json:"edges"`
+	Nodes      []IdentityWrapper `json:"nodes"`
+	PageInfo   *PageInfo         `json:"pageInfo"`
+	TotalCount int               `json:"totalCount"`
 }
 
 type IdentityEdge struct {
-	Cursor string             `json:"cursor"`
-	Node   identity.Interface `json:"node"`
+	Cursor string          `json:"cursor"`
+	Node   IdentityWrapper `json:"node"`
 }
 
 type LabelConnection struct {
@@ -185,7 +184,7 @@ type NewBugPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The created bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
 	Operation *bug.CreateOperation `json:"operation"`
 }
@@ -203,7 +202,7 @@ type OpenBugPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
 	Operation *bug.SetStatusOperation `json:"operation"`
 }
@@ -249,7 +248,7 @@ type SetTitlePayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId"`
 	// The affected bug.
-	Bug *bug.Snapshot `json:"bug"`
+	Bug BugWrapper `json:"bug"`
 	// The resulting operation
 	Operation *bug.SetTitleOperation `json:"operation"`
 }
diff --git a/graphql/models/lazy_bug.go b/graphql/models/lazy_bug.go
new file mode 100644
index 00000000..6034e80d
--- /dev/null
+++ b/graphql/models/lazy_bug.go
@@ -0,0 +1,215 @@
+package models
+
+import (
+	"sync"
+	"time"
+
+	"github.com/MichaelMure/git-bug/bug"
+	"github.com/MichaelMure/git-bug/cache"
+	"github.com/MichaelMure/git-bug/entity"
+)
+
+// BugWrapper is an interface used by the GraphQL resolvers to handle a bug.
+// Depending on the situation, a Bug can already be fully loaded in memory or not.
+// This interface is used to wrap either a lazyBug or a loadedBug depending on the situation.
+type BugWrapper interface {
+	Id() entity.Id
+	LastEdit() time.Time
+	Status() bug.Status
+	Title() string
+	Comments() ([]bug.Comment, error)
+	Labels() []bug.Label
+	Author() (IdentityWrapper, error)
+	Actors() ([]IdentityWrapper, error)
+	Participants() ([]IdentityWrapper, error)
+	CreatedAt() time.Time
+	Timeline() ([]bug.TimelineItem, error)
+	Operations() ([]bug.Operation, error)
+
+	IsAuthored()
+}
+
+var _ BugWrapper = &lazyBug{}
+
+// lazyBug is a lazy-loading wrapper that fetch data from the cache (BugExcerpt) in priority,
+// and load the complete bug and snapshot only when necessary.
+type lazyBug struct {
+	cache   *cache.RepoCache
+	excerpt *cache.BugExcerpt
+
+	mu   sync.Mutex
+	snap *bug.Snapshot
+}
+
+func NewLazyBug(cache *cache.RepoCache, excerpt *cache.BugExcerpt) *lazyBug {
+	return &lazyBug{
+		cache:   cache,
+		excerpt: excerpt,
+	}
+}
+
+func (lb *lazyBug) load() error {
+	if lb.snap != nil {
+		return nil
+	}
+
+	lb.mu.Lock()
+	defer lb.mu.Unlock()
+
+	b, err := lb.cache.ResolveBug(lb.excerpt.Id)
+	if err != nil {
+		return err
+	}
+
+	lb.snap = b.Snapshot()
+	return nil
+}
+
+func (lb *lazyBug) identity(id entity.Id) (IdentityWrapper, error) {
+	i, err := lb.cache.ResolveIdentityExcerpt(id)
+	if err != nil {
+		return nil, err
+	}
+	return &lazyIdentity{cache: lb.cache, excerpt: i}, nil
+}
+
+// Sign post method for gqlgen
+func (lb *lazyBug) IsAuthored() {}
+
+func (lb *lazyBug) Id() entity.Id {
+	return lb.excerpt.Id
+}
+
+func (lb *lazyBug) LastEdit() time.Time {
+	return time.Unix(lb.excerpt.EditUnixTime, 0)
+}
+
+func (lb *lazyBug) Status() bug.Status {
+	return lb.excerpt.Status
+}
+
+func (lb *lazyBug) Title() string {
+	return lb.excerpt.Title
+}
+
+func (lb *lazyBug) Comments() ([]bug.Comment, error) {
+	err := lb.load()
+	if err != nil {
+		return nil, err
+	}
+	return lb.snap.Comments, nil
+}
+
+func (lb *lazyBug) Labels() []bug.Label {
+	return lb.excerpt.Labels
+}
+
+func (lb *lazyBug) Author() (IdentityWrapper, error) {
+	return lb.identity(lb.excerpt.AuthorId)
+}
+
+func (lb *lazyBug) Actors() ([]IdentityWrapper, error) {
+	result := make([]IdentityWrapper, len(lb.excerpt.Actors))
+	for i, actorId := range lb.excerpt.Actors {
+		actor, err := lb.identity(actorId)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = actor
+	}
+	return result, nil
+}
+
+func (lb *lazyBug) Participants() ([]IdentityWrapper, error) {
+	result := make([]IdentityWrapper, len(lb.excerpt.Participants))
+	for i, participantId := range lb.excerpt.Participants {
+		participant, err := lb.identity(participantId)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = participant
+	}
+	return result, nil
+}
+
+func (lb *lazyBug) CreatedAt() time.Time {
+	return time.Unix(lb.excerpt.CreateUnixTime, 0)
+}
+
+func (lb *lazyBug) Timeline() ([]bug.TimelineItem, error) {
+	err := lb.load()
+	if err != nil {
+		return nil, err
+	}
+	return lb.snap.Timeline, nil
+}
+
+func (lb *lazyBug) Operations() ([]bug.Operation, error) {
+	err := lb.load()
+	if err != nil {
+		return nil, err
+	}
+	return lb.snap.Operations, nil
+}
+
+var _ BugWrapper = &loadedBug{}
+
+type loadedBug struct {
+	*bug.Snapshot
+}
+
+func NewLoadedBug(snap *bug.Snapshot) *loadedBug {
+	return &loadedBug{Snapshot: snap}
+}
+
+func (l *loadedBug) LastEdit() time.Time {
+	return l.Snapshot.LastEditTime()
+}
+
+func (l *loadedBug) Status() bug.Status {
+	return l.Snapshot.Status
+}
+
+func (l *loadedBug) Title() string {
+	return l.Snapshot.Title
+}
+
+func (l *loadedBug) Comments() ([]bug.Comment, error) {
+	return l.Snapshot.Comments, nil
+}
+
+func (l *loadedBug) Labels() []bug.Label {
+	return l.Snapshot.Labels
+}
+
+func (l *loadedBug) Author() (IdentityWrapper, error) {
+	return NewLoadedIdentity(l.Snapshot.Author), nil
+}
+
+func (l *loadedBug) Actors() ([]IdentityWrapper, error) {
+	res := make([]IdentityWrapper, len(l.Snapshot.Actors))
+	for i, actor := range l.Snapshot.Actors {
+		res[i] = NewLoadedIdentity(actor)
+	}
+	return res, nil
+}
+
+func (l *loadedBug) Participants() ([]IdentityWrapper, error) {
+	res := make([]IdentityWrapper, len(l.Snapshot.Participants))
+	for i, participant := range l.Snapshot.Participants {
+		res[i] = NewLoadedIdentity(participant)
+	}
+	return res, nil
+}
+
+func (l *loadedBug) CreatedAt() time.Time {
+	return l.Snapshot.CreatedAt
+}
+
+func (l *loadedBug) Timeline() ([]bug.TimelineItem, error) {
+	return l.Snapshot.Timeline, nil
+}
+
+func (l *loadedBug) Operations() ([]bug.Operation, error) {
+	return l.Snapshot.Operations, nil
+}
diff --git a/graphql/models/lazy_identity.go b/graphql/models/lazy_identity.go
new file mode 100644
index 00000000..bbd36be3
--- /dev/null
+++ b/graphql/models/lazy_identity.go
@@ -0,0 +1,167 @@
+package models
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/MichaelMure/git-bug/cache"
+	"github.com/MichaelMure/git-bug/entity"
+	"github.com/MichaelMure/git-bug/identity"
+	"github.com/MichaelMure/git-bug/util/lamport"
+	"github.com/MichaelMure/git-bug/util/timestamp"
+)
+
+// IdentityWrapper is an interface used by the GraphQL resolvers to handle an identity.
+// Depending on the situation, an Identity can already be fully loaded in memory or not.
+// This interface is used to wrap either a lazyIdentity or a loadedIdentity depending on the situation.
+type IdentityWrapper interface {
+	Id() entity.Id
+	Name() string
+	Email() (string, error)
+	AvatarUrl() (string, error)
+	Keys() ([]*identity.Key, error)
+	ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error)
+	DisplayName() string
+	IsProtected() (bool, error)
+	LastModificationLamport() (lamport.Time, error)
+	LastModification() (timestamp.Timestamp, error)
+}
+
+var _ IdentityWrapper = &lazyIdentity{}
+
+type lazyIdentity struct {
+	cache   *cache.RepoCache
+	excerpt *cache.IdentityExcerpt
+
+	mu sync.Mutex
+	id *cache.IdentityCache
+}
+
+func NewLazyIdentity(cache *cache.RepoCache, excerpt *cache.IdentityExcerpt) *lazyIdentity {
+	return &lazyIdentity{
+		cache:   cache,
+		excerpt: excerpt,
+	}
+}
+
+func (li *lazyIdentity) load() (*cache.IdentityCache, error) {
+	if li.id != nil {
+		return li.id, nil
+	}
+
+	li.mu.Lock()
+	defer li.mu.Unlock()
+
+	id, err := li.cache.ResolveIdentity(li.excerpt.Id)
+	if err != nil {
+		return nil, fmt.Errorf("cache: missing identity %v", li.excerpt.Id)
+	}
+	li.id = id
+	return id, nil
+}
+
+func (li *lazyIdentity) Id() entity.Id {
+	return li.excerpt.Id
+}
+
+func (li *lazyIdentity) Name() string {
+	return li.excerpt.Name
+}
+
+func (li *lazyIdentity) Email() (string, error) {
+	id, err := li.load()
+	if err != nil {
+		return "", err
+	}
+	return id.Email(), nil
+}
+
+func (li *lazyIdentity) AvatarUrl() (string, error) {
+	id, err := li.load()
+	if err != nil {
+		return "", err
+	}
+	return id.AvatarUrl(), nil
+}
+
+func (li *lazyIdentity) Keys() ([]*identity.Key, error) {
+	id, err := li.load()
+	if err != nil {
+		return nil, err
+	}
+	return id.Keys(), nil
+}
+
+func (li *lazyIdentity) ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error) {
+	id, err := li.load()
+	if err != nil {
+		return nil, err
+	}
+	return id.ValidKeysAtTime(time), nil
+}
+
+func (li *lazyIdentity) DisplayName() string {
+	return li.excerpt.DisplayName()
+}
+
+func (li *lazyIdentity) IsProtected() (bool, error) {
+	id, err := li.load()
+	if err != nil {
+		return false, err
+	}
+	return id.IsProtected(), nil
+}
+
+func (li *lazyIdentity) LastModificationLamport() (lamport.Time, error) {
+	id, err := li.load()
+	if err != nil {
+		return 0, err
+	}
+	return id.LastModificationLamport(), nil
+}
+
+func (li *lazyIdentity) LastModification() (timestamp.Timestamp, error) {
+	id, err := li.load()
+	if err != nil {
+		return 0, err
+	}
+	return id.LastModification(), nil
+}
+
+var _ IdentityWrapper = &loadedIdentity{}
+
+type loadedIdentity struct {
+	identity.Interface
+}
+
+func NewLoadedIdentity(id identity.Interface) *loadedIdentity {
+	return &loadedIdentity{Interface: id}
+}
+
+func (l loadedIdentity) Email() (string, error) {
+	return l.Interface.Email(), nil
+}
+
+func (l loadedIdentity) AvatarUrl() (string, error) {
+	return l.Interface.AvatarUrl(), nil
+}
+
+func (l loadedIdentity) Keys() ([]*identity.Key, error) {
+	return l.Interface.Keys(), nil
+}
+
+func (l loadedIdentity) ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error) {
+	return l.Interface.ValidKeysAtTime(time), nil
+}
+
+func (l loadedIdentity) IsProtected() (bool, error) {
+	return l.Interface.IsProtected(), nil
+}
+
+func (l loadedIdentity) LastModificationLamport() (lamport.Time, error) {
+	return l.Interface.LastModificationLamport(), nil
+}
+
+func (l loadedIdentity) LastModification() (timestamp.Timestamp, error) {
+	return l.Interface.LastModification(), nil
+}