patch of draft: appview: service layer · round #1 · pull #800 · tangled.org/core

+18

appview/service/issue/context.go

···

       1
       +
       package issue

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/models"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type ctxKey struct{}

     

       10
       +
       

     

       11
       +
       func IntoContext(ctx context.Context, repo *models.Issue) context.Context {

     

       12
       +
       	return context.WithValue(ctx, ctxKey{}, repo)

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func FromContext(ctx context.Context) (*models.Issue, bool) {

     

       16
       +
       	repo, ok := ctx.Value(ctxKey{}).(*models.Issue)

     

       17
       +
       	return repo, ok

     

       18
       +
       }

+213

appview/service/issue/issue.go

···

       1
       +
       package issue

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"errors"

     

       6
       +
       	"log/slog"

     

       7
       +
       	"time"

     

       8
       +
       

     

       9
       +
       	"github.com/bluesky-social/indigo/api/atproto"

     

       10
       +
       	"github.com/bluesky-social/indigo/atproto/auth/oauth"

     

       11
       +
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       	"tangled.org/core/api/tangled"

     

       13
       +
       	"tangled.org/core/appview/config"

     

       14
       +
       	"tangled.org/core/appview/db"

     

       15
       +
       	"tangled.org/core/appview/models"

     

       16
       +
       	"tangled.org/core/appview/notify"

     

       17
       +
       	"tangled.org/core/appview/refresolver"

     

       18
       +
       	"tangled.org/core/tid"

     

       19
       +
       )

     

       20
       +
       

     

       21
       +
       type IssueService struct {

     

       22
       +
       	logger      *slog.Logger

     

       23
       +
       	config      *config.Config

     

       24
       +
       	db          *db.DB

     

       25
       +
       	notifier    notify.Notifier

     

       26
       +
       	refResolver *refresolver.Resolver

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       func NewService(

     

       30
       +
       	logger *slog.Logger,

     

       31
       +
       	config *config.Config,

     

       32
       +
       	db *db.DB,

     

       33
       +
       	notifier notify.Notifier,

     

       34
       +
       	refResolver *refresolver.Resolver,

     

       35
       +
       ) IssueService {

     

       36
       +
       	return IssueService{

     

       37
       +
       		logger,

     

       38
       +
       		config,

     

       39
       +
       		db,

     

       40
       +
       		notifier,

     

       41
       +
       		refResolver,

     

       42
       +
       	}

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       var (

     

       46
       +
       	ErrCtxMissing     = errors.New("context values are missing")

     

       47
       +
       	ErrDatabaseFail   = errors.New("db op fail")

     

       48
       +
       	ErrPDSFail        = errors.New("pds op fail")

     

       49
       +
       	ErrValidationFail = errors.New("issue validation fail")

     

       50
       +
       )

     

       51
       +
       

     

       52
       +
       // TODO: NewIssue should return typed errors

     

       53
       +
       func (s *IssueService) NewIssue(ctx context.Context, repo *models.Repo, title, body string) (*models.Issue, error) {

     

       54
       +
       	l := s.logger.With("method", "NewIssue")

     

       55
       +
       	sess, ok := fromContext(ctx)

     

       56
       +
       	if !ok {

     

       57
       +
       		l.Error("user session is missing in context")

     

       58
       +
       		return nil, ErrCtxMissing

     

       59
       +
       	}

     

       60
       +
       	authorDid := sess.Data.AccountDID

     

       61
       +
       	l = l.With("did", authorDid)

     

       62
       +
       

     

       63
       +
       	mentions, references := s.refResolver.Resolve(ctx, body)

     

       64
       +
       

     

       65
       +
       	issue := models.Issue{

     

       66
       +
       		RepoAt:     repo.RepoAt(),

     

       67
       +
       		Rkey:       tid.TID(),

     

       68
       +
       		Title:      title,

     

       69
       +
       		Body:       body,

     

       70
       +
       		Open:       true,

     

       71
       +
       		Did:        authorDid.String(),

     

       72
       +
       		Created:    time.Now(),

     

       73
       +
       		Mentions:   mentions,

     

       74
       +
       		References: references,

     

       75
       +
       		Repo:       repo,

     

       76
       +
       	}

     

       77
       +
       	// TODO: validate the issue

     

       78
       +
       

     

       79
       +
       	tx, err := s.db.BeginTx(ctx, nil)

     

       80
       +
       	if err != nil {

     

       81
       +
       		l.Error("db.BeginTx failed", "err", err)

     

       82
       +
       		return nil, ErrDatabaseFail

     

       83
       +
       	}

     

       84
       +
       	defer tx.Rollback()

     

       85
       +
       

     

       86
       +
       	if err := db.PutIssue(tx, &issue); err != nil {

     

       87
       +
       		l.Error("db.PutIssue failed", "err", err)

     

       88
       +
       		return nil, ErrDatabaseFail

     

       89
       +
       	}

     

       90
       +
       

     

       91
       +
       	atpclient := sess.APIClient()

     

       92
       +
       	record := issue.AsRecord()

     

       93
       +
       	_, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{

     

       94
       +
       		Repo:       authorDid.String(),

     

       95
       +
       		Collection: tangled.RepoIssueNSID,

     

       96
       +
       		Rkey:       issue.Rkey,

     

       97
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       98
       +
       			Val: &record,

     

       99
       +
       		},

     

       100
       +
       	})

     

       101
       +
       	if err != nil {

     

       102
       +
       		l.Error("atproto.RepoPutRecord failed", "err", err)

     

       103
       +
       		return nil, ErrPDSFail

     

       104
       +
       	}

     

       105
       +
       	if err = tx.Commit(); err != nil {

     

       106
       +
       		l.Error("tx.Commit failed", "err", err)

     

       107
       +
       		return nil, ErrDatabaseFail

     

       108
       +
       	}

     

       109
       +
       

     

       110
       +
       	s.notifier.NewIssue(ctx, &issue, mentions)

     

       111
       +
       	return &issue, nil

     

       112
       +
       }

     

       113
       +
       

     

       114
       +
       func (s *IssueService) EditIssue(ctx context.Context, issue *models.Issue) error {

     

       115
       +
       	l := s.logger.With("method", "EditIssue")

     

       116
       +
       	sess, ok := fromContext(ctx)

     

       117
       +
       	if !ok {

     

       118
       +
       		l.Error("user session is missing in context")

     

       119
       +
       		return ErrCtxMissing

     

       120
       +
       	}

     

       121
       +
       	authorDid := sess.Data.AccountDID

     

       122
       +
       	l = l.With("did", authorDid)

     

       123
       +
       

     

       124
       +
       	// TODO: validate issue

     

       125
       +
       

     

       126
       +
       	tx, err := s.db.BeginTx(ctx, nil)

     

       127
       +
       	if err != nil {

     

       128
       +
       		l.Error("db.BeginTx failed", "err", err)

     

       129
       +
       		return ErrDatabaseFail

     

       130
       +
       	}

     

       131
       +
       	defer tx.Rollback()

     

       132
       +
       

     

       133
       +
       	if err := db.PutIssue(tx, issue); err != nil {

     

       134
       +
       		l.Error("db.PutIssue failed", "err", err)

     

       135
       +
       		return ErrDatabaseFail

     

       136
       +
       	}

     

       137
       +
       

     

       138
       +
       	atpclient := sess.APIClient()

     

       139
       +
       	record := issue.AsRecord()

     

       140
       +
       

     

       141
       +
       	ex, err := atproto.RepoGetRecord(ctx, atpclient, "", tangled.RepoIssueNSID, issue.Did, issue.Rkey)

     

       142
       +
       	if err != nil {

     

       143
       +
       		l.Error("atproto.RepoGetRecord failed", "err", err)

     

       144
       +
       		return ErrPDSFail

     

       145
       +
       	}

     

       146
       +
       	_, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{

     

       147
       +
       		Collection: tangled.RepoIssueNSID,

     

       148
       +
       		SwapRecord: ex.Cid,

     

       149
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       150
       +
       			Val: &record,

     

       151
       +
       		},

     

       152
       +
       	})

     

       153
       +
       	if err != nil {

     

       154
       +
       		l.Error("atproto.RepoPutRecord failed", "err", err)

     

       155
       +
       		return ErrPDSFail

     

       156
       +
       	}

     

       157
       +
       

     

       158
       +
       	if err = tx.Commit(); err != nil {

     

       159
       +
       		l.Error("tx.Commit failed", "err", err)

     

       160
       +
       		return ErrDatabaseFail

     

       161
       +
       	}

     

       162
       +
       

     

       163
       +
       	// TODO: notify PutIssue

     

       164
       +
       

     

       165
       +
       	return nil

     

       166
       +
       }

     

       167
       +
       

     

       168
       +
       func (s *IssueService) DeleteIssue(ctx context.Context, issue *models.Issue) error {

     

       169
       +
       	l := s.logger.With("method", "DeleteIssue")

     

       170
       +
       	sess, ok := fromContext(ctx)

     

       171
       +
       	if !ok {

     

       172
       +
       		return ErrCtxMissing

     

       173
       +
       	}

     

       174
       +
       	authorDid := sess.Data.AccountDID

     

       175
       +
       	l = l.With("did", authorDid)

     

       176
       +
       

     

       177
       +
       	tx, err := s.db.BeginTx(ctx, nil)

     

       178
       +
       	if err != nil {

     

       179
       +
       		l.Error("db.BeginTx failed", "err", err)

     

       180
       +
       		return ErrDatabaseFail

     

       181
       +
       	}

     

       182
       +
       	defer tx.Rollback()

     

       183
       +
       

     

       184
       +
       	if err := db.DeleteIssues(tx, issue.Did, issue.Rkey); err != nil {

     

       185
       +
       		l.Error("db.DeleteIssues failed", "err", err)

     

       186
       +
       		return ErrDatabaseFail

     

       187
       +
       	}

     

       188
       +
       

     

       189
       +
       	atpclient := sess.APIClient()

     

       190
       +
       	_, err = atproto.RepoDeleteRecord(ctx, atpclient, &atproto.RepoDeleteRecord_Input{

     

       191
       +
       		Collection: tangled.RepoIssueNSID,

     

       192
       +
       		Repo:       issue.Did,

     

       193
       +
       		Rkey:       issue.Rkey,

     

       194
       +
       	})

     

       195
       +
       	if err != nil {

     

       196
       +
       		l.Error("atproto.RepoDeleteRecord failed", "err", err)

     

       197
       +
       		return ErrPDSFail

     

       198
       +
       	}

     

       199
       +
       

     

       200
       +
       	if err := tx.Commit(); err != nil {

     

       201
       +
       		l.Error("tx.Commit failed", "err", err)

     

       202
       +
       		return ErrDatabaseFail

     

       203
       +
       	}

     

       204
       +
       

     

       205
       +
       	s.notifier.DeleteIssue(ctx, issue)

     

       206
       +
       	return nil

     

       207
       +
       }

     

       208
       +
       

     

       209
       +
       // TODO: remove this

     

       210
       +
       func fromContext(ctx context.Context) (*oauth.ClientSession, bool) {

     

       211
       +
       	sess, ok := ctx.Value("sess").(*oauth.ClientSession)

     

       212
       +
       	return sess, ok

     

       213
       +
       }

+15

appview/service/issue/state.go

···

       1
       +
       package issue

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/models"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func (s *IssueService) CloseIssue(ctx context.Context, iusse *models.Issue) error {

     

       10
       +
       	panic("unimplemented")

     

       11
       +
       }

     

       12
       +
       

     

       13
       +
       func (s *IssueService) ReopenIssue(ctx context.Context, iusse *models.Issue) error {

     

       14
       +
       	panic("unimplemented")

     

       15
       +
       }

+18

appview/service/owner/context.go

···

       1
       +
       package owner

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type ctxKey struct{}

     

       10
       +
       

     

       11
       +
       func IntoContext(ctx context.Context, id *identity.Identity) context.Context {

     

       12
       +
       	return context.WithValue(ctx, ctxKey{}, id)

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func FromContext(ctx context.Context) (*identity.Identity, bool) {

     

       16
       +
       	repo, ok := ctx.Value(ctxKey{}).(*identity.Identity)

     

       17
       +
       	return repo, ok

     

       18
       +
       }

+18

appview/service/repo/context.go

···

       1
       +
       package repo

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/models"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type ctxKey struct{}

     

       10
       +
       

     

       11
       +
       func IntoContext(ctx context.Context, repo *models.Repo) context.Context {

     

       12
       +
       	return context.WithValue(ctx, ctxKey{}, repo)

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func FromContext(ctx context.Context) (*models.Repo, bool) {

     

       16
       +
       	repo, ok := ctx.Value(ctxKey{}).(*models.Repo)

     

       17
       +
       	return repo, ok

     

       18
       +
       }

+71

appview/service/repo/repo.go

···

       1
       +
       package repo

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"fmt"

     

       6
       +
       	"log/slog"

     

       7
       +
       	"time"

     

       8
       +
       

     

       9
       +
       	"github.com/bluesky-social/indigo/api/atproto"

     

       10
       +
       	"github.com/bluesky-social/indigo/atproto/auth/oauth"

     

       11
       +
       	"tangled.org/core/api/tangled"

     

       12
       +
       	"tangled.org/core/appview/config"

     

       13
       +
       	"tangled.org/core/appview/db"

     

       14
       +
       	"tangled.org/core/appview/models"

     

       15
       +
       	"tangled.org/core/rbac"

     

       16
       +
       	"tangled.org/core/tid"

     

       17
       +
       )

     

       18
       +
       

     

       19
       +
       type RepoService struct {

     

       20
       +
       	logger   *slog.Logger

     

       21
       +
       	config   *config.Config

     

       22
       +
       	db       *db.DB

     

       23
       +
       	enforcer *rbac.Enforcer

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       // NewRepo creates a repository

     

       27
       +
       // It expects atproto session to be passed in `ctx`

     

       28
       +
       func (s *RepoService) NewRepo(ctx context.Context, name, description, knot string) error {

     

       29
       +
       	l := s.logger.With("method", "NewRepo")

     

       30
       +
       	sess := fromContext(ctx)

     

       31
       +
       

     

       32
       +
       	ownerDid := sess.Data.AccountDID

     

       33
       +
       	l = l.With("did", ownerDid)

     

       34
       +
       

     

       35
       +
       	repo := models.Repo{

     

       36
       +
       		Did:         ownerDid.String(),

     

       37
       +
       		Name:        name,

     

       38
       +
       		Knot:        knot,

     

       39
       +
       		Rkey:        tid.TID(),

     

       40
       +
       		Description: description,

     

       41
       +
       		Created:     time.Now(),

     

       42
       +
       		Labels:      s.config.Label.DefaultLabelDefs,

     

       43
       +
       	}

     

       44
       +
       	l = l.With("aturi", repo.RepoAt())

     

       45
       +
       

     

       46
       +
       	tx, err := s.db.BeginTx(ctx, nil)

     

       47
       +
       	if err != nil {

     

       48
       +
       		return fmt.Errorf("db.BeginTx: %w", err)

     

       49
       +
       	}

     

       50
       +
       	defer tx.Rollback()

     

       51
       +
       

     

       52
       +
       

     

       53
       +
       	atpclient := sess.APIClient()

     

       54
       +
       	_, err = atproto.RepoPutRecord(ctx, atpclient, &atproto.RepoPutRecord_Input{

     

       55
       +
       		Collection: tangled.RepoNSID,

     

       56
       +
       		Repo: repo.Did,

     

       57
       +
       	})

     

       58
       +
       	if err != nil {

     

       59
       +
       		return fmt.Errorf("atproto.RepoPutRecord: %w", err)

     

       60
       +
       	}

     

       61
       +
       	l.Info("wrote to PDS")

     

       62
       +
       

     

       63
       +
       	// knotclient, err := s.oauth.ServiceClient(

     

       64
       +
       	// )

     

       65
       +
       

     

       66
       +
       	return nil

     

       67
       +
       }

     

       68
       +
       

     

       69
       +
       func fromContext(ctx context.Context) oauth.ClientSession {

     

       70
       +
       	panic("todo")

     

       71
       +
       }

+12

appview/state/router.go

···

       18
        
       	"tangled.org/core/appview/spindles"

     

       19
        
       	"tangled.org/core/appview/state/userutil"

     

       20
        
       	avstrings "tangled.org/core/appview/strings"

     

       0
        
       
     

       21
        
       	"tangled.org/core/log"

     

       22
        
       )

     

       23
        
       

     
···

       40
        
       	userRouter := s.UserRouter(&middleware)

     

       41
        
       	standardRouter := s.StandardRouter(&middleware)

     

       42
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

       44
        
       		pat := chi.URLParam(r, "*")

     

       45
        
       		pathParts := strings.SplitN(pat, "/", 2)

···

       18
        
       	"tangled.org/core/appview/spindles"

     

       19
        
       	"tangled.org/core/appview/state/userutil"

     

       20
        
       	avstrings "tangled.org/core/appview/strings"

     

       21
       +
       	"tangled.org/core/appview/web"

     

       22
        
       	"tangled.org/core/log"

     

       23
        
       )

     

       24
        
       

     
···

       41
        
       	userRouter := s.UserRouter(&middleware)

     

       42
        
       	standardRouter := s.StandardRouter(&middleware)

     

       43
        
       

     

       44
       +
       	_ = web.UserRouter(

     

       45
       +
       		s.logger,

     

       46
       +
       		s.config,

     

       47
       +
       		s.db,

     

       48
       +
       		s.idResolver,

     

       49
       +
       		s.refResolver,

     

       50
       +
       		s.notifier,

     

       51
       +
       		s.oauth,

     

       52
       +
       		s.pages,

     

       53
       +
       	)

     

       54
       +
       

     

       55
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

       56
        
       		pat := chi.URLParam(r, "*")

     

       57
        
       		pathParts := strings.SplitN(pat, "/", 2)

+12

appview/web/handler/issues.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func RepoIssues(s issue.IssueService) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       	}

     

       12
       +
       }

+35

appview/web/handler/issues_issue.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/pages"

     

       7
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       8
       +
       	"tangled.org/core/log"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       func Issue(s isvc.IssueService) http.HandlerFunc {

     

       12
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       13
       +
       		panic("unimplemented")

     

       14
       +
       	}

     

       15
       +
       }

     

       16
       +
       

     

       17
       +
       func IssueDelete(s isvc.IssueService, p *pages.Pages) http.HandlerFunc {

     

       18
       +
       	noticeId := "issue-actions-error"

     

       19
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       20
       +
       		ctx := r.Context()

     

       21
       +
       		l := log.FromContext(ctx).With("handler", "IssueDelete")

     

       22
       +
       		issue, ok := isvc.FromContext(ctx)

     

       23
       +
       		if !ok {

     

       24
       +
       			l.Error("failed to get issue")

     

       25
       +
       			// TODO: 503 error with more detailed messages

     

       26
       +
       			p.Error503(w)

     

       27
       +
       			return

     

       28
       +
       		}

     

       29
       +
       		err := s.DeleteIssue(ctx, issue)

     

       30
       +
       		if err != nil {

     

       31
       +
       			p.Notice(w, noticeId, "failed to delete issue")

     

       32
       +
       		}

     

       33
       +
       		p.HxLocation(w, "/")

     

       34
       +
       	}

     

       35
       +
       }

+13

appview/web/handler/issues_issue_close.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func CloseIssue(s issue.IssueService) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

+19

appview/web/handler/issues_issue_edit.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func IssueEdit(s issue.IssueService) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func IssueEditPost(s issue.IssueService) http.HandlerFunc {

     

       16
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       17
       +
       		panic("unimplemented")

     

       18
       +
       	}

     

       19
       +
       }

+13

appview/web/handler/issues_issue_opengraph.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func IssueOpenGraph(s issue.IssueService) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

+13

appview/web/handler/issues_issue_reopen.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func ReopenIssue(s issue.IssueService) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

+48

appview/web/handler/issues_new.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"errors"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

       7
       +
       	"tangled.org/core/appview/pages"

     

       8
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       9
       +
       	"tangled.org/core/appview/service/repo"

     

       10
       +
       	"tangled.org/core/log"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       func NewIssue(p *pages.Pages) http.HandlerFunc {

     

       14
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       15
       +
       		// TODO: render page

     

       16
       +
       	}

     

       17
       +
       }

     

       18
       +
       

     

       19
       +
       func NewIssuePost(is isvc.IssueService, p *pages.Pages) http.HandlerFunc {

     

       20
       +
       	noticeId := "issues"

     

       21
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       22
       +
       		ctx := r.Context()

     

       23
       +
       		l := log.FromContext(ctx).With("handler", "NewIssuePost")

     

       24
       +
       		repo, ok := repo.FromContext(ctx)

     

       25
       +
       		if !ok {

     

       26
       +
       			l.Error("failed to get repo")

     

       27
       +
       			// TODO: 503 error with more detailed messages

     

       28
       +
       			p.Error503(w)

     

       29
       +
       			return

     

       30
       +
       		}

     

       31
       +
       		var (

     

       32
       +
       			title = r.FormValue("title")

     

       33
       +
       			body  = r.FormValue("body")

     

       34
       +
       		)

     

       35
       +
       

     

       36
       +
       		_, err := is.NewIssue(ctx, repo, title, body)

     

       37
       +
       		if err != nil {

     

       38
       +
       			if errors.Is(err, isvc.ErrDatabaseFail) {

     

       39
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       40
       +
       			} else if errors.Is(err, isvc.ErrPDSFail) {

     

       41
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       42
       +
       			} else {

     

       43
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       44
       +
       			}

     

       45
       +
       		}

     

       46
       +
       		p.HxLocation(w, "/")

     

       47
       +
       	}

     

       48
       +
       }

appview/web/handler/repos_new.go

···

       0

···

       1
       +
       package handler

appview/web/handler/repos_repo.go

···

       1
       +
       package handler

     

       2
       +

appview/web/handler/repos_repo_opengraph.go

···

       1
       +
       package handler

     

       2
       +

+51

appview/web/middleware/auth.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"fmt"

     

       6
       +
       	"log"

     

       7
       +
       	"net/http"

     

       8
       +
       	"net/url"

     

       9
       +
       

     

       10
       +
       	"tangled.org/core/appview/oauth"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       func AuthMiddleware(o *oauth.OAuth) middlewareFunc {

     

       14
       +
       	return func(next http.Handler) http.Handler {

     

       15
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       16
       +
       			returnURL := "/"

     

       17
       +
       			if u, err := url.Parse(r.Header.Get("Referer")); err == nil {

     

       18
       +
       				returnURL = u.RequestURI()

     

       19
       +
       			}

     

       20
       +
       

     

       21
       +
       			loginURL := fmt.Sprintf("/login?return_url=%s", url.QueryEscape(returnURL))

     

       22
       +
       

     

       23
       +
       			redirectFunc := func(w http.ResponseWriter, r *http.Request) {

     

       24
       +
       				http.Redirect(w, r, loginURL, http.StatusTemporaryRedirect)

     

       25
       +
       			}

     

       26
       +
       			if r.Header.Get("HX-Request") == "true" {

     

       27
       +
       				redirectFunc = func(w http.ResponseWriter, _ *http.Request) {

     

       28
       +
       					w.Header().Set("HX-Redirect", loginURL)

     

       29
       +
       					w.WriteHeader(http.StatusOK)

     

       30
       +
       				}

     

       31
       +
       			}

     

       32
       +
       

     

       33
       +
       			sess, err := o.ResumeSession(r)

     

       34
       +
       			if err != nil {

     

       35
       +
       				log.Println("failed to resume session, redirecting...", "err", err, "url", r.URL.String())

     

       36
       +
       				redirectFunc(w, r)

     

       37
       +
       				return

     

       38
       +
       			}

     

       39
       +
       

     

       40
       +
       			if sess == nil {

     

       41
       +
       				log.Printf("session is nil, redirecting...")

     

       42
       +
       				redirectFunc(w, r)

     

       43
       +
       				return

     

       44
       +
       			}

     

       45
       +
       

     

       46
       +
       			// TODO: use IntoContext instead

     

       47
       +
       			ctx := context.WithValue(r.Context(), "sess", sess)

     

       48
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       49
       +
       		})

     

       50
       +
       	}

     

       51
       +
       }

+18

appview/web/middleware/log.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"log/slog"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

       7
       +
       	"tangled.org/core/log"

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       func WithLogger(l *slog.Logger) middlewareFunc {

     

       11
       +
       	return func(next http.Handler) http.Handler {

     

       12
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       13
       +
       			// NOTE: can add some metadata here

     

       14
       +
       			ctx := log.IntoContext(r.Context(), l)

     

       15
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       16
       +
       		})

     

       17
       +
       	}

     

       18
       +
       }

appview/web/middleware/middleware.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type middlewareFunc func(http.Handler) http.Handler

+38

appview/web/middleware/paginate.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"log"

     

       5
       +
       	"net/http"

     

       6
       +
       	"strconv"

     

       7
       +
       

     

       8
       +
       	"tangled.org/core/appview/pagination"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       func Paginate(next http.Handler) http.Handler {

     

       12
       +
       	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       13
       +
       		page := pagination.FirstPage()

     

       14
       +
       

     

       15
       +
       		offsetVal := r.URL.Query().Get("offset")

     

       16
       +
       		if offsetVal != "" {

     

       17
       +
       			offset, err := strconv.Atoi(offsetVal)

     

       18
       +
       			if err != nil {

     

       19
       +
       				log.Println("invalid offset")

     

       20
       +
       			} else {

     

       21
       +
       				page.Offset = offset

     

       22
       +
       			}

     

       23
       +
       		}

     

       24
       +
       

     

       25
       +
       		limitVal := r.URL.Query().Get("limit")

     

       26
       +
       		if limitVal != "" {

     

       27
       +
       			limit, err := strconv.Atoi(limitVal)

     

       28
       +
       			if err != nil {

     

       29
       +
       				log.Println("invalid limit")

     

       30
       +
       			} else {

     

       31
       +
       				page.Limit = limit

     

       32
       +
       			}

     

       33
       +
       		}

     

       34
       +
       

     

       35
       +
       		ctx := pagination.IntoContext(r.Context(), page)

     

       36
       +
       		next.ServeHTTP(w, r.WithContext(ctx))

     

       37
       +
       	})

     

       38
       +
       }

+114

appview/web/middleware/resolve.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"log"

     

       5
       +
       	"net/http"

     

       6
       +
       	"strconv"

     

       7
       +
       	"strings"

     

       8
       +
       

     

       9
       +
       	"github.com/go-chi/chi/v5"

     

       10
       +
       	"tangled.org/core/appview/db"

     

       11
       +
       	"tangled.org/core/appview/pages"

     

       12
       +
       	issue_service "tangled.org/core/appview/service/issue"

     

       13
       +
       	owner_service "tangled.org/core/appview/service/owner"

     

       14
       +
       	repo_service "tangled.org/core/appview/service/repo"

     

       15
       +
       	"tangled.org/core/idresolver"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       func ResolveIdent(

     

       19
       +
       	idResolver *idresolver.Resolver,

     

       20
       +
       	pages *pages.Pages,

     

       21
       +
       ) middlewareFunc {

     

       22
       +
       	return func(next http.Handler) http.Handler {

     

       23
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       24
       +
       			didOrHandle := chi.URLParam(r, "user")

     

       25
       +
       			didOrHandle = strings.TrimPrefix(didOrHandle, "@")

     

       26
       +
       

     

       27
       +
       			id, err := idResolver.ResolveIdent(r.Context(), didOrHandle)

     

       28
       +
       			if err != nil {

     

       29
       +
       				// invalid did or handle

     

       30
       +
       				log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err)

     

       31
       +
       				pages.Error404(w)

     

       32
       +
       				return

     

       33
       +
       			}

     

       34
       +
       

     

       35
       +
       			ctx := owner_service.IntoContext(r.Context(), id)

     

       36
       +
       			log.Println("ident resolved")

     

       37
       +
       

     

       38
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       39
       +
       		})

     

       40
       +
       	}

     

       41
       +
       }

     

       42
       +
       

     

       43
       +
       func ResolveRepo(

     

       44
       +
       	e *db.DB,

     

       45
       +
       	idResolver *idresolver.Resolver,

     

       46
       +
       	pages *pages.Pages,

     

       47
       +
       ) middlewareFunc {

     

       48
       +
       	return func(next http.Handler) http.Handler {

     

       49
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       50
       +
       			repoName := chi.URLParam(r, "repo")

     

       51
       +
       			repoOwner, ok := owner_service.FromContext(r.Context())

     

       52
       +
       			if !ok {

     

       53
       +
       				log.Println("malformed middleware")

     

       54
       +
       				w.WriteHeader(http.StatusInternalServerError)

     

       55
       +
       				return

     

       56
       +
       			}

     

       57
       +
       

     

       58
       +
       			repo, err := db.GetRepo(

     

       59
       +
       				e,

     

       60
       +
       				db.FilterEq("did", repoOwner.DID.String()),

     

       61
       +
       				db.FilterEq("name", repoName),

     

       62
       +
       			)

     

       63
       +
       			if err != nil {

     

       64
       +
       				log.Println("failed to resolve repo", "err", err)

     

       65
       +
       				pages.ErrorKnot404(w)

     

       66
       +
       				return

     

       67
       +
       			}

     

       68
       +
       

     

       69
       +
       			// TODO: pass owner id into repository object

     

       70
       +
       

     

       71
       +
       			ctx := repo_service.IntoContext(r.Context(), repo)

     

       72
       +
       			log.Println("repo resolved")

     

       73
       +
       

     

       74
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       75
       +
       		})

     

       76
       +
       	}

     

       77
       +
       }

     

       78
       +
       

     

       79
       +
       func ResolveIssue(

     

       80
       +
       	e *db.DB,

     

       81
       +
       	idResolver *idresolver.Resolver,

     

       82
       +
       	pages *pages.Pages,

     

       83
       +
       ) middlewareFunc {

     

       84
       +
       	return func(next http.Handler) http.Handler {

     

       85
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       86
       +
       			issueIdStr := chi.URLParam(r, "issue")

     

       87
       +
       			issueId, err := strconv.Atoi(issueIdStr)

     

       88
       +
       			if err != nil {

     

       89
       +
       				log.Println("failed to fully resolve issue ID", err)

     

       90
       +
       				pages.Error404(w)

     

       91
       +
       				return

     

       92
       +
       			}

     

       93
       +
       			repo, ok := repo_service.FromContext(r.Context())

     

       94
       +
       			if !ok {

     

       95
       +
       				log.Println("malformed middleware")

     

       96
       +
       				w.WriteHeader(http.StatusInternalServerError)

     

       97
       +
       				return

     

       98
       +
       			}

     

       99
       +
       

     

       100
       +
       			issue, err := db.GetIssue(e, repo.RepoAt(), issueId)

     

       101
       +
       			if err != nil {

     

       102
       +
       				log.Println("failed to resolve repo", "err", err)

     

       103
       +
       				pages.ErrorKnot404(w)

     

       104
       +
       				return

     

       105
       +
       			}

     

       106
       +
       			issue.Repo = repo

     

       107
       +
       

     

       108
       +
       			ctx := issue_service.IntoContext(r.Context(), issue)

     

       109
       +
       			log.Println("issue resolved")

     

       110
       +
       

     

       111
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       112
       +
       		})

     

       113
       +
       	}

     

       114
       +
       }

+88

appview/web/routes.go

···

       1
       +
       package web

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"log/slog"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

       7
       +
       	"github.com/go-chi/chi/v5"

     

       8
       +
       	"tangled.org/core/appview/config"

     

       9
       +
       	"tangled.org/core/appview/db"

     

       10
       +
       	"tangled.org/core/appview/notify"

     

       11
       +
       	"tangled.org/core/appview/oauth"

     

       12
       +
       	"tangled.org/core/appview/pages"

     

       13
       +
       	"tangled.org/core/appview/refresolver"

     

       14
       +
       	"tangled.org/core/appview/service/issue"

     

       15
       +
       	"tangled.org/core/appview/web/handler"

     

       16
       +
       	"tangled.org/core/appview/web/middleware"

     

       17
       +
       	"tangled.org/core/idresolver"

     

       18
       +
       )

     

       19
       +
       

     

       20
       +
       // Rules

     

       21
       +
       // - Use single function for each endpoints (unless it doesn't make sense.)

     

       22
       +
       // - Name handler files following the related path (ancestor paths can be

     

       23
       +
       //   trimmed.)

     

       24
       +
       // - Uass dependencies to each handlers, don't create structs with shared

     

       25
       +
       //   dependencies unless it serves some domain-specific roles like

     

       26
       +
       //   service/issue. Same rule goes to middlewares.

     

       27
       +
       

     

       28
       +
       func UserRouter(

     

       29
       +
       	// NOTE: put base dependencies (db, idResolver, oauth etc)

     

       30
       +
       	logger *slog.Logger,

     

       31
       +
       	config *config.Config,

     

       32
       +
       	db *db.DB,

     

       33
       +
       	idResolver *idresolver.Resolver,

     

       34
       +
       	refResolver *refresolver.Resolver,

     

       35
       +
       	notifier notify.Notifier,

     

       36
       +
       	oauth *oauth.OAuth,

     

       37
       +
       	pages *pages.Pages,

     

       38
       +
       ) http.Handler {

     

       39
       +
       	r := chi.NewRouter()

     

       40
       +
       

     

       41
       +
       	auth := middleware.AuthMiddleware(oauth)

     

       42
       +
       

     

       43
       +
       	issue := issue.NewService(

     

       44
       +
       		logger,

     

       45
       +
       		config,

     

       46
       +
       		db,

     

       47
       +
       		notifier,

     

       48
       +
       		refResolver,

     

       49
       +
       	)

     

       50
       +
       

     

       51
       +
       	r.Use(middleware.WithLogger(logger))

     

       52
       +
       

     

       53
       +
       	r.Route("/{user}", func(r chi.Router) {

     

       54
       +
       		r.Use(middleware.ResolveIdent(idResolver, pages))

     

       55
       +
       

     

       56
       +
       		// r.Get("/", Profile)

     

       57
       +
       		// r.Get("/feed.atom", AtomFeedPage)

     

       58
       +
       

     

       59
       +
       		r.Route("/{repo}", func(r chi.Router) {

     

       60
       +
       			r.Use(middleware.ResolveRepo(db, idResolver, pages))

     

       61
       +
       

     

       62
       +
       			// /{user}/{repo}/issues/*

     

       63
       +
       			r.With(middleware.Paginate).Get("/issues", handler.RepoIssues(issue))

     

       64
       +
       			r.With(auth).Get("/issues/new", handler.NewIssue(pages))

     

       65
       +
       			r.With(auth).Post("/issues/new", handler.NewIssuePost(issue, pages))

     

       66
       +
       			r.Route("/issues/{issue}", func(r chi.Router) {

     

       67
       +
       				r.Use(middleware.ResolveIssue(db, idResolver, pages))

     

       68
       +
       

     

       69
       +
       				r.Get("/", handler.Issue(issue))

     

       70
       +
       				r.Get("/opengraph", handler.IssueOpenGraph(issue))

     

       71
       +
       

     

       72
       +
       				r.With(auth).Delete("/", handler.IssueDelete(issue, pages))

     

       73
       +
       

     

       74
       +
       				r.With(auth).Get("/edit", handler.IssueEdit(issue))

     

       75
       +
       				r.With(auth).Post("/edit", handler.IssueEditPost(issue))

     

       76
       +
       

     

       77
       +
       				r.With(auth).Post("/close", handler.CloseIssue(issue))

     

       78
       +
       				r.With(auth).Post("/reopen", handler.ReopenIssue(issue))

     

       79
       +
       

     

       80
       +
       				// TODO: comments

     

       81
       +
       			})

     

       82
       +
       

     

       83
       +
       			// TODO: put more routes

     

       84
       +
       		})

     

       85
       +
       	})

     

       86
       +
       

     

       87
       +
       	return r

     

       88
       +
       }