comparing 6b0222850b1e4ea5f1f8526c0b81205e28ed15c7 and push-kyupnpkvqmsy on nel.pet/core

+29 -1

appview/models/notifications.go

···

       1
       1
        
       package models

     

       2
       2
        
       

     

       3
       3
       -
       import "time"

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"time"

     

       5
       5
       +
       )

     

       4
       6
        
       

     

       5
       7
        
       type NotificationType string

     

       6
       8
        
       

     
···

       32
       34
        
       	PullId  *int64

     

       33
       35
        
       }

     

       34
       36
        
       

     

       37
       37
       +
       // lucide icon that represents this notification

     

       38
       38
       +
       func (n *Notification) Icon() string {

     

       39
       39
       +
       	switch n.Type {

     

       40
       40
       +
       	case NotificationTypeRepoStarred:

     

       41
       41
       +
       		return "star"

     

       42
       42
       +
       	case NotificationTypeIssueCreated:

     

       43
       43
       +
       		return "circle-dot"

     

       44
       44
       +
       	case NotificationTypeIssueCommented:

     

       45
       45
       +
       		return "message-square"

     

       46
       46
       +
       	case NotificationTypeIssueClosed:

     

       47
       47
       +
       		return "ban"

     

       48
       48
       +
       	case NotificationTypePullCreated:

     

       49
       49
       +
       		return "git-pull-request-create"

     

       50
       50
       +
       	case NotificationTypePullCommented:

     

       51
       51
       +
       		return "message-square"

     

       52
       52
       +
       	case NotificationTypePullMerged:

     

       53
       53
       +
       		return "git-merge"

     

       54
       54
       +
       	case NotificationTypePullClosed:

     

       55
       55
       +
       		return "git-pull-request-closed"

     

       56
       56
       +
       	case NotificationTypeFollowed:

     

       57
       57
       +
       		return "user-plus"

     

       58
       58
       +
       	default:

     

       59
       59
       +
       		return ""

     

       60
       60
       +
       	}

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       35
       63
        
       type NotificationWithEntity struct {

     

       36
       64
        
       	*Notification

     

       37
       65
        
       	Repo  *Repo

+18 -13

appview/db/notifications.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"database/sql"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"fmt"

     

       8
       8
       +
       	"strings"

     

       7
       9
        
       	"time"

     

       8
       10
        
       

     

       9
       11
        
       	"tangled.org/core/appview/models"

     
···

       248
       250
        
       	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       249
       251
        
       }

     

       250
       252
        
       

     

       251
       251
       -
       func (d *DB) GetUnreadNotificationCount(ctx context.Context, userDID string) (int, error) {

     

       252
       252
       -
       	recipientFilter := FilterEq("recipient_did", userDID)

     

       253
       253
       -
       	readFilter := FilterEq("read", 0)

     

       253
       253
       +
       func CountNotifications(e Execer, filters ...filter) (int64, error) {

     

       254
       254
       +
       	var conditions []string

     

       255
       255
       +
       	var args []any

     

       256
       256
       +
       	for _, filter := range filters {

     

       257
       257
       +
       		conditions = append(conditions, filter.Condition())

     

       258
       258
       +
       		args = append(args, filter.Arg()...)

     

       259
       259
       +
       	}

     

       254
       260
        
       

     

       255
       255
       -
       	query := fmt.Sprintf(`

     

       256
       256
       -
       		SELECT COUNT(*)

     

       257
       257
       -
       		FROM notifications

     

       258
       258
       -
       		WHERE %s AND %s

     

       259
       259
       -
       	`, recipientFilter.Condition(), readFilter.Condition())

     

       261
       261
       +
       	whereClause := ""

     

       262
       262
       +
       	if conditions != nil {

     

       263
       263
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       264
       264
       +
       	}

     

       260
       265
        
       

     

       261
       261
       -
       	args := append(recipientFilter.Arg(), readFilter.Arg()...)

     

       266
       266
       +
       	query := fmt.Sprintf(`select count(1) from notifications %s`, whereClause)

     

       267
       267
       +
       	var count int64

     

       268
       268
       +
       	err := e.QueryRow(query, args...).Scan(&count)

     

       262
       269
        
       

     

       263
       263
       -
       	var count int

     

       264
       264
       -
       	err := d.DB.QueryRowContext(ctx, query, args...).Scan(&count)

     

       265
       265
       -
       	if err != nil {

     

       266
       266
       -
       		return 0, fmt.Errorf("failed to get unread count: %w", err)

     

       270
       270
       +
       	if !errors.Is(err, sql.ErrNoRows) && err != nil {

     

       271
       271
       +
       		return 0, err

     

       267
       272
        
       	}

     

       268
       273
        
       

     

       269
       274
        
       	return count, nil

+29 -36

appview/notifications/notifications.go

···

       1
       1
        
       package notifications

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"fmt"

     

       4
       5
        
       	"log"

     

       5
       6
        
       	"net/http"

     

       6
       7
        
       	"strconv"

     
···

       32
       33
        
       

     

       33
       34
        
       	r.Use(middleware.AuthMiddleware(n.oauth))

     

       34
       35
        
       

     

       35
       35
       -
       	r.Get("/", n.notificationsPage)

     

       36
       36
       +
       	r.With(middleware.Paginate).Get("/", n.notificationsPage)

     

       36
       37
        
       

     

       37
       38
        
       	r.Get("/count", n.getUnreadCount)

     

       38
       39
        
       	r.Post("/{id}/read", n.markRead)

     
···

       45
       46
        
       func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {

     

       46
       47
        
       	userDid := n.oauth.GetDid(r)

     

       47
       48
        
       

     

       48
       48
       -
       	limitStr := r.URL.Query().Get("limit")

     

       49
       49
       -
       	offsetStr := r.URL.Query().Get("offset")

     

       50
       50
       -
       

     

       51
       51
       -
       	limit := 20 // default

     

       52
       52
       -
       	if limitStr != "" {

     

       53
       53
       -
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {

     

       54
       54
       -
       			limit = l

     

       55
       55
       -
       		}

     

       49
       49
       +
       	page, ok := r.Context().Value("page").(pagination.Page)

     

       50
       50
       +
       	if !ok {

     

       51
       51
       +
       		log.Println("failed to get page")

     

       52
       52
       +
       		page = pagination.FirstPage()

     

       56
       53
        
       	}

     

       57
       54
        
       

     

       58
       58
       -
       	offset := 0 // default

     

       59
       59
       -
       	if offsetStr != "" {

     

       60
       60
       -
       		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {

     

       61
       61
       -
       			offset = o

     

       62
       62
       -
       		}

     

       55
       55
       +
       	total, err := db.CountNotifications(

     

       56
       56
       +
       		n.db,

     

       57
       57
       +
       		db.FilterEq("recipient_did", userDid),

     

       58
       58
       +
       	)

     

       59
       59
       +
       	if err != nil {

     

       60
       60
       +
       		log.Println("failed to get total notifications:", err)

     

       61
       61
       +
       		n.pages.Error500(w)

     

       62
       62
       +
       		return

     

       63
       63
        
       	}

     

       64
       64
        
       

     

       65
       65
       -
       	page := pagination.Page{Limit: limit + 1, Offset: offset}

     

       66
       66
       -
       	notifications, err := db.GetNotificationsWithEntities(n.db, page, db.FilterEq("recipient_did", userDid))

     

       65
       65
       +
       	notifications, err := db.GetNotificationsWithEntities(

     

       66
       66
       +
       		n.db,

     

       67
       67
       +
       		page,

     

       68
       68
       +
       		db.FilterEq("recipient_did", userDid),

     

       69
       69
       +
       	)

     

       67
       70
        
       	if err != nil {

     

       68
       71
        
       		log.Println("failed to get notifications:", err)

     

       69
       72
        
       		n.pages.Error500(w)

     

       70
       73
        
       		return

     

       71
       74
        
       	}

     

       72
       75
        
       

     

       73
       73
       -
       	hasMore := len(notifications) > limit

     

       74
       74
       -
       	if hasMore {

     

       75
       75
       -
       		notifications = notifications[:limit]

     

       76
       76
       -
       	}

     

       77
       77
       -
       

     

       78
       76
        
       	err = n.db.MarkAllNotificationsRead(r.Context(), userDid)

     

       79
       77
        
       	if err != nil {

     

       80
       78
        
       		log.Println("failed to mark notifications as read:", err)

     
···

       88
       86
        
       		return

     

       89
       87
        
       	}

     

       90
       88
        
       

     

       91
       91
       -
       	params := pages.NotificationsParams{

     

       89
       89
       +
       	fmt.Println(n.pages.Notifications(w, pages.NotificationsParams{

     

       92
       90
        
       		LoggedInUser:  user,

     

       93
       91
        
       		Notifications: notifications,

     

       94
       92
        
       		UnreadCount:   unreadCount,

     

       95
       95
       -
       		HasMore:       hasMore,

     

       96
       96
       -
       		NextOffset:    offset + limit,

     

       97
       97
       -
       		Limit:         limit,

     

       98
       98
       -
       	}

     

       99
       99
       -
       

     

       100
       100
       -
       	err = n.pages.Notifications(w, params)

     

       101
       101
       -
       	if err != nil {

     

       102
       102
       -
       		log.Println("failed to load notifs:", err)

     

       103
       103
       -
       		n.pages.Error500(w)

     

       104
       104
       -
       		return

     

       105
       105
       -
       	}

     

       93
       93
       +
       		Page:          page,

     

       94
       94
       +
       		Total:         total,

     

       95
       95
       +
       	}))

     

       106
       96
        
       }

     

       107
       97
        
       

     

       108
       98
        
       func (n *Notifications) getUnreadCount(w http.ResponseWriter, r *http.Request) {

     

       109
       109
       -
       	userDid := n.oauth.GetDid(r)

     

       110
       110
       -
       

     

       111
       111
       -
       	count, err := n.db.GetUnreadNotificationCount(r.Context(), userDid)

     

       99
       99
       +
       	user := n.oauth.GetUser(r)

     

       100
       100
       +
       	count, err := db.CountNotifications(

     

       101
       101
       +
       		n.db,

     

       102
       102
       +
       		db.FilterEq("recipient_did", user.Did),

     

       103
       103
       +
       		db.FilterEq("read", 0),

     

       104
       104
       +
       	)

     

       112
       105
        
       	if err != nil {

     

       113
       106
        
       		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)

     

       114
       107
        
       		return

+3 -4

appview/pages/pages.go

···

       326
       326
        
       	LoggedInUser  *oauth.User

     

       327
       327
        
       	Notifications []*models.NotificationWithEntity

     

       328
       328
        
       	UnreadCount   int

     

       329
       329
       -
       	HasMore       bool

     

       330
       330
       -
       	NextOffset    int

     

       331
       331
       -
       	Limit         int

     

       329
       329
       +
       	Page          pagination.Page

     

       330
       330
       +
       	Total         int64

     

       332
       331
        
       }

     

       333
       332
        
       

     

       334
       333
        
       func (p *Pages) Notifications(w io.Writer, params NotificationsParams) error {

     
···

       344
       343
        
       }

     

       345
       344
        
       

     

       346
       345
        
       type NotificationCountParams struct {

     

       347
       347
       -
       	Count int

     

       346
       346
       +
       	Count int64

     

       348
       347
        
       }

     

       349
       348
        
       

     

       350
       349
        
       func (p *Pages) NotificationCount(w io.Writer, params NotificationCountParams) error {

+1 -1

appview/pagination/page.go

···

       8
       8
        
       func FirstPage() Page {

     

       9
       9
        
       	return Page{

     

       10
       10
        
       		Offset: 0,

     

       11
       11
       -
       		Limit:  10,

     

       11
       11
       +
       		Limit:  30,

     

       12
       12
        
       	}

     

       13
       13
        
       }

     

       14
       14

+1 -1

nix/pkgs/knot-unwrapped.nix

···

       4
       4
        
         sqlite-lib,

     

       5
       5
        
         src,

     

       6
       6
        
       }: let

     

       7
       7
       -
         version = "1.9.0-alpha";

     

       7
       7
       +
         version = "1.9.1-alpha";

     

       8
       8
        
       in

     

       9
       9
        
         buildGoApplication {

     

       10
       10
        
           pname = "knot";

+1 -1

appview/pages/templates/layouts/fragments/footer.html

···

       23
       23
        
                 <a href="https://blog.tangled.org" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a>

     

       24
       24
        
                 <a href="https://tangled.org/@tangled.org/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a>

     

       25
       25
        
                 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a>

     

       26
       26
       -
                 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a>

     

       26
       26
       +
                 <a href="https://tangled.org/brand" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a>

     

       27
       27
        
               </div>

     

       28
       28
        
       

     

       29
       29
        
               <div class="flex flex-col gap-1">

+1 -1

appview/signup/signup.go

···

       133
       133
        
       		noticeId := "signup-msg"

     

       134
       134
        
       

     

       135
       135
        
       		if err := s.validateCaptcha(cfToken, r); err != nil {

     

       136
       136
       -
       			s.l.Warn("turnstile validation failed", "error", err)

     

       136
       136
       +
       			s.l.Warn("turnstile validation failed", "error", err, "email", emailId)

     

       137
       137
        
       			s.pages.Notice(w, noticeId, "Captcha validation failed.")

     

       138
       138
        
       			return

     

       139
       139
        
       		}

+1 -1

appview/pages/templates/repo/fragments/cloneDropdown.html

···

       1
       1
        
       {{ define "repo/fragments/cloneDropdown" }}

     

       2
       2
        
           {{ $knot := .RepoInfo.Knot }}

     

       3
       3
        
           {{ if eq $knot "knot1.tangled.sh" }}

     

       4
       4
       -
               {{ $knot = "tangled.sh" }}

     

       4
       4
       +
               {{ $knot = "tangled.org" }}

     

       5
       5
        
           {{ end }}

     

       6
       6
        
       

     

       7
       7
        
           <details id="clone-dropdown" class="relative inline-block text-left group">

+1 -1

docs/spindle/pipeline.md

···

       21
       21
        
         - `manual`: The workflow can be triggered manually.

     

       22
       22
        
       - `branch`: This is a **required** field that defines which branches the workflow should run for. If used with the `push` event, commits to the branch(es) listed here will trigger the workflow. If used with the `pull_request` event, updates to pull requests targeting the branch(es) listed here will trigger the workflow. This field has no effect with the `manual` event.

     

       23
       23
        
       

     

       24
       24
       -
       For example, if you'd like define a workflow that runs when commits are pushed to the `main` and `develop` branches, or when pull requests that target the `main` branch are updated, or manually, you can do so with:

     

       24
       24
       +
       For example, if you'd like to define a workflow that runs when commits are pushed to the `main` and `develop` branches, or when pull requests that target the `main` branch are updated, or manually, you can do so with:

     

       25
       25
        
       

     

       26
       26
        
       ```yaml

     

       27
       27
        
       when:

+1 -1

knotserver/config/config.go

···

       41
       41
        
       	Repo            Repo   `env:",prefix=KNOT_REPO_"`

     

       42
       42
        
       	Server          Server `env:",prefix=KNOT_SERVER_"`

     

       43
       43
        
       	Git             Git    `env:",prefix=KNOT_GIT_"`

     

       44
       44
       -
       	AppViewEndpoint string `env:"APPVIEW_ENDPOINT, default=https://tangled.sh"`

     

       44
       44
       +
       	AppViewEndpoint string `env:"APPVIEW_ENDPOINT, default=https://tangled.org"`

     

       45
       45
        
       }

     

       46
       46
        
       

     

       47
       47
        
       func Load(ctx context.Context) (*Config, error) {

+3

appview/pages/templates/layouts/base.html

···

       14
       14
        
                   <link rel="preconnect" href="https://avatar.tangled.sh" />

     

       15
       15
        
                   <link rel="preconnect" href="https://camo.tangled.sh" />

     

       16
       16
        
       

     

       17
       17
       +
                   <!-- pwa manifest -->

     

       18
       18
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       19
       19
       +
       

     

       17
       20
        
                   <!-- preload main font -->

     

       18
       21
        
                   <link rel="preload" href="/static/fonts/InterVariable.woff2" as="font" type="font/woff2" crossorigin />

     

       19
       22

+1

appview/pages/templates/user/completeSignup.html

···

       20
       20
        
                       content="complete your signup for tangled"

     

       21
       21
        
                   />

     

       22
       22
        
                   <script src="/static/htmx.min.js"></script>

     

       23
       23
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       23
       24
        
                   <link

     

       24
       25
        
                       rel="stylesheet"

     

       25
       26
        
                       href="/static/tw.css?{{ cssContentHash }}"

+1

appview/pages/templates/user/login.html

···

       8
       8
        
                   <meta property="og:url" content="https://tangled.org/login" />

     

       9
       9
        
                   <meta property="og:description" content="login to for tangled" />

     

       10
       10
        
                   <script src="/static/htmx.min.js"></script>

     

       11
       11
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       11
       12
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       12
       13
        
                   <title>login &middot; tangled</title>

     

       13
       14
        
               </head>

+1

appview/pages/templates/user/signup.html

···

       8
       8
        
                   <meta property="og:url" content="https://tangled.org/signup" />

     

       9
       9
        
                   <meta property="og:description" content="sign up for tangled" />

     

       10
       10
        
                   <script src="/static/htmx.min.js"></script>

     

       11
       11
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       11
       12
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       12
       13
        
                   <title>sign up &middot; tangled</title>

     

       13
       14

+1

appview/state/router.go

···

       37
       37
        
       	router.Use(middleware.TryRefreshSession())

     

       38
       38
        
       	router.Get("/favicon.svg", s.Favicon)

     

       39
       39
        
       	router.Get("/favicon.ico", s.Favicon)

     

       40
       40
       +
       	router.Get("/pwa-manifest.json", s.PWAManifest)

     

       40
       41
        
       

     

       41
       42
        
       	userRouter := s.UserRouter(&middleware)

     

       42
       43
        
       	standardRouter := s.StandardRouter(&middleware)

+23

appview/state/state.go

···

       198
       198
        
       	s.pages.Favicon(w)

     

       199
       199
        
       }

     

       200
       200
        
       

     

       201
       201
       +
       // https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Manifest

     

       202
       202
       +
       const manifestJson = `{

     

       203
       203
       +
         "name": "tangled",

     

       204
       204
       +
         "description": "tightly-knit social coding.",

     

       205
       205
       +
         "icons": [

     

       206
       206
       +
           {

     

       207
       207
       +
             "src": "/favicon.svg",

     

       208
       208
       +
             "sizes": "144x144"

     

       209
       209
       +
           }

     

       210
       210
       +
         ],

     

       211
       211
       +
         "start_url": "/",

     

       212
       212
       +
         "id": "org.tangled",

     

       213
       213
       +
       

     

       214
       214
       +
         "display": "standalone",

     

       215
       215
       +
         "background_color": "#111827",

     

       216
       216
       +
         "theme_color": "#111827"

     

       217
       217
       +
       }`

     

       218
       218
       +
       

     

       219
       219
       +
       func (p *State) PWAManifest(w http.ResponseWriter, r *http.Request) {

     

       220
       220
       +
       	w.Header().Set("Content-Type", "application/json")

     

       221
       221
       +
       	w.Write([]byte(manifestJson))

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       201
       224
        
       func (s *State) TermsOfService(w http.ResponseWriter, r *http.Request) {

     

       202
       225
        
       	user := s.oauth.GetUser(r)

     

       203
       226
        
       	s.pages.TermsOfService(w, pages.TermsOfServiceParams{

+34

appview/db/language.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"database/sql"

     

       4
       5
        
       	"fmt"

     

       5
       6
        
       	"strings"

     

       6
       7
        
       

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       9
        
       	"tangled.org/core/appview/models"

     

       8
       10
        
       )

     

       9
       11
        
       

     
···

       82
       84
        
       

     

       83
       85
        
       	return nil

     

       84
       86
        
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func DeleteRepoLanguages(e Execer, filters ...filter) error {

     

       89
       89
       +
       	var conditions []string

     

       90
       90
       +
       	var args []any

     

       91
       91
       +
       	for _, filter := range filters {

     

       92
       92
       +
       		conditions = append(conditions, filter.Condition())

     

       93
       93
       +
       		args = append(args, filter.Arg()...)

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	whereClause := ""

     

       97
       97
       +
       	if conditions != nil {

     

       98
       98
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	query := fmt.Sprintf(`delete from repo_languages %s`, whereClause)

     

       102
       102
       +
       

     

       103
       103
       +
       	_, err := e.Exec(query, args...)

     

       104
       104
       +
       	return err

     

       105
       105
       +
       }

     

       106
       106
       +
       

     

       107
       107
       +
       func UpdateRepoLanguages(tx *sql.Tx, repoAt syntax.ATURI, ref string, langs []models.RepoLanguage) error {

     

       108
       108
       +
       	err := DeleteRepoLanguages(

     

       109
       109
       +
       		tx,

     

       110
       110
       +
       		FilterEq("repo_at", repoAt),

     

       111
       111
       +
       		FilterEq("ref", ref),

     

       112
       112
       +
       	)

     

       113
       113
       +
       	if err != nil {

     

       114
       114
       +
       		return fmt.Errorf("failed to delete existing languages: %w", err)

     

       115
       115
       +
       	}

     

       116
       116
       +
       

     

       117
       117
       +
       	return InsertRepoLanguages(tx, langs)

     

       118
       118
       +
       }

+12 -1

appview/repo/index.go

···

       200
       200
        
       			})

     

       201
       201
        
       		}

     

       202
       202
        
       

     

       203
       203
       +
       		tx, err := rp.db.Begin()

     

       204
       204
       +
       		if err != nil {

     

       205
       205
       +
       			return nil, err

     

       206
       206
       +
       		}

     

       207
       207
       +
       		defer tx.Rollback()

     

       208
       208
       +
       

     

       203
       209
        
       		// update appview's cache

     

       204
       204
       -
       		err = db.InsertRepoLanguages(rp.db, langs)

     

       210
       210
       +
       		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       205
       211
        
       		if err != nil {

     

       206
       212
        
       			// non-fatal

     

       207
       213
        
       			log.Println("failed to cache lang results", err)

     

       208
       214
        
       		}

     

       215
       215
       +
       

     

       216
       216
       +
       		err = tx.Commit()

     

       217
       217
       +
       		if err != nil {

     

       218
       218
       +
       			return nil, err

     

       219
       219
       +
       		}

     

       209
       220
        
       	}

     

       210
       221
        
       

     

       211
       222
        
       	var total int64

+14 -1

appview/state/knotstream.go

···

       172
       172
        
       		})

     

       173
       173
        
       	}

     

       174
       174
        
       

     

       175
       175
       -
       	return db.InsertRepoLanguages(d, langs)

     

       175
       175
       +
       	tx, err := d.Begin()

     

       176
       176
       +
       	if err != nil {

     

       177
       177
       +
       		return err

     

       178
       178
       +
       	}

     

       179
       179
       +
       	defer tx.Rollback()

     

       180
       180
       +
       

     

       181
       181
       +
       	// update appview's cache

     

       182
       182
       +
       	err = db.UpdateRepoLanguages(tx, repo.RepoAt(), ref.Short(), langs)

     

       183
       183
       +
       	if err != nil {

     

       184
       184
       +
       		fmt.Printf("failed; %s\n", err)

     

       185
       185
       +
       		// non-fatal

     

       186
       186
       +
       	}

     

       187
       187
       +
       

     

       188
       188
       +
       	return tx.Commit()

     

       176
       189
        
       }

     

       177
       190
        
       

     

       178
       191
        
       func ingestPipeline(d *db.DB, source ec.Source, msg ec.Message) error {

+202 -1

api/tangled/cbor_gen.go

···

       7420
       7420
        
       	}

     

       7421
       7421
        
       

     

       7422
       7422
        
       	cw := cbg.NewCborWriter(w)

     

       7423
       7423
       -
       	fieldCount := 7

     

       7423
       7423
       +
       	fieldCount := 8

     

       7424
       7424
        
       

     

       7425
       7425
        
       	if t.Body == nil {

     

       7426
       7426
        
       		fieldCount--

     
···

       7430
       7430
        
       		fieldCount--

     

       7431
       7431
        
       	}

     

       7432
       7432
        
       

     

       7433
       7433
       +
       	if t.StackInfo == nil {

     

       7434
       7434
       +
       		fieldCount--

     

       7435
       7435
       +
       	}

     

       7436
       7436
       +
       

     

       7433
       7437
        
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       7434
       7438
        
       		return err

     

       7435
       7439
        
       	}

     
···

       7588
       7592
        
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       7589
       7593
        
       		return err

     

       7590
       7594
        
       	}

     

       7595
       7595
       +
       

     

       7596
       7596
       +
       	// t.StackInfo (tangled.RepoPull_StackInfo) (struct)

     

       7597
       7597
       +
       	if t.StackInfo != nil {

     

       7598
       7598
       +
       

     

       7599
       7599
       +
       		if len("stackInfo") > 1000000 {

     

       7600
       7600
       +
       			return xerrors.Errorf("Value in field \"stackInfo\" was too long")

     

       7601
       7601
       +
       		}

     

       7602
       7602
       +
       

     

       7603
       7603
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stackInfo"))); err != nil {

     

       7604
       7604
       +
       			return err

     

       7605
       7605
       +
       		}

     

       7606
       7606
       +
       		if _, err := cw.WriteString(string("stackInfo")); err != nil {

     

       7607
       7607
       +
       			return err

     

       7608
       7608
       +
       		}

     

       7609
       7609
       +
       

     

       7610
       7610
       +
       		if err := t.StackInfo.MarshalCBOR(cw); err != nil {

     

       7611
       7611
       +
       			return err

     

       7612
       7612
       +
       		}

     

       7613
       7613
       +
       	}

     

       7591
       7614
        
       	return nil

     

       7592
       7615
        
       }

     

       7593
       7616
        
       

     
···

       7737
       7760
        
       

     

       7738
       7761
        
       				t.CreatedAt = string(sval)

     

       7739
       7762
        
       			}

     

       7763
       7763
       +
       			// t.StackInfo (tangled.RepoPull_StackInfo) (struct)

     

       7764
       7764
       +
       		case "stackInfo":

     

       7765
       7765
       +
       

     

       7766
       7766
       +
       			{

     

       7767
       7767
       +
       

     

       7768
       7768
       +
       				b, err := cr.ReadByte()

     

       7769
       7769
       +
       				if err != nil {

     

       7770
       7770
       +
       					return err

     

       7771
       7771
       +
       				}

     

       7772
       7772
       +
       				if b != cbg.CborNull[0] {

     

       7773
       7773
       +
       					if err := cr.UnreadByte(); err != nil {

     

       7774
       7774
       +
       						return err

     

       7775
       7775
       +
       					}

     

       7776
       7776
       +
       					t.StackInfo = new(RepoPull_StackInfo)

     

       7777
       7777
       +
       					if err := t.StackInfo.UnmarshalCBOR(cr); err != nil {

     

       7778
       7778
       +
       						return xerrors.Errorf("unmarshaling t.StackInfo pointer: %w", err)

     

       7779
       7779
       +
       					}

     

       7780
       7780
       +
       				}

     

       7781
       7781
       +
       

     

       7782
       7782
       +
       			}

     

       7740
       7783
        
       

     

       7741
       7784
        
       		default:

     

       7742
       7785
        
       			// Field doesn't exist on this type, so ignore it

     
···

       7946
       7989
        
       

     

       7947
       7990
        
       	return nil

     

       7948
       7991
        
       }

     

       7992
       7992
       +
       func (t *RepoPull_StackInfo) MarshalCBOR(w io.Writer) error {

     

       7993
       7993
       +
       	if t == nil {

     

       7994
       7994
       +
       		_, err := w.Write(cbg.CborNull)

     

       7995
       7995
       +
       		return err

     

       7996
       7996
       +
       	}

     

       7997
       7997
       +
       

     

       7998
       7998
       +
       	cw := cbg.NewCborWriter(w)

     

       7999
       7999
       +
       	fieldCount := 2

     

       8000
       8000
       +
       

     

       8001
       8001
       +
       	if t.Parent == nil {

     

       8002
       8002
       +
       		fieldCount--

     

       8003
       8003
       +
       	}

     

       8004
       8004
       +
       

     

       8005
       8005
       +
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       8006
       8006
       +
       		return err

     

       8007
       8007
       +
       	}

     

       8008
       8008
       +
       

     

       8009
       8009
       +
       	// t.Parent (string) (string)

     

       8010
       8010
       +
       	if t.Parent != nil {

     

       8011
       8011
       +
       

     

       8012
       8012
       +
       		if len("parent") > 1000000 {

     

       8013
       8013
       +
       			return xerrors.Errorf("Value in field \"parent\" was too long")

     

       8014
       8014
       +
       		}

     

       8015
       8015
       +
       

     

       8016
       8016
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil {

     

       8017
       8017
       +
       			return err

     

       8018
       8018
       +
       		}

     

       8019
       8019
       +
       		if _, err := cw.WriteString(string("parent")); err != nil {

     

       8020
       8020
       +
       			return err

     

       8021
       8021
       +
       		}

     

       8022
       8022
       +
       

     

       8023
       8023
       +
       		if t.Parent == nil {

     

       8024
       8024
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       8025
       8025
       +
       				return err

     

       8026
       8026
       +
       			}

     

       8027
       8027
       +
       		} else {

     

       8028
       8028
       +
       			if len(*t.Parent) > 1000000 {

     

       8029
       8029
       +
       				return xerrors.Errorf("Value in field t.Parent was too long")

     

       8030
       8030
       +
       			}

     

       8031
       8031
       +
       

     

       8032
       8032
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Parent))); err != nil {

     

       8033
       8033
       +
       				return err

     

       8034
       8034
       +
       			}

     

       8035
       8035
       +
       			if _, err := cw.WriteString(string(*t.Parent)); err != nil {

     

       8036
       8036
       +
       				return err

     

       8037
       8037
       +
       			}

     

       8038
       8038
       +
       		}

     

       8039
       8039
       +
       	}

     

       8040
       8040
       +
       

     

       8041
       8041
       +
       	// t.ChangeId (string) (string)

     

       8042
       8042
       +
       	if len("changeId") > 1000000 {

     

       8043
       8043
       +
       		return xerrors.Errorf("Value in field \"changeId\" was too long")

     

       8044
       8044
       +
       	}

     

       8045
       8045
       +
       

     

       8046
       8046
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changeId"))); err != nil {

     

       8047
       8047
       +
       		return err

     

       8048
       8048
       +
       	}

     

       8049
       8049
       +
       	if _, err := cw.WriteString(string("changeId")); err != nil {

     

       8050
       8050
       +
       		return err

     

       8051
       8051
       +
       	}

     

       8052
       8052
       +
       

     

       8053
       8053
       +
       	if len(t.ChangeId) > 1000000 {

     

       8054
       8054
       +
       		return xerrors.Errorf("Value in field t.ChangeId was too long")

     

       8055
       8055
       +
       	}

     

       8056
       8056
       +
       

     

       8057
       8057
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChangeId))); err != nil {

     

       8058
       8058
       +
       		return err

     

       8059
       8059
       +
       	}

     

       8060
       8060
       +
       	if _, err := cw.WriteString(string(t.ChangeId)); err != nil {

     

       8061
       8061
       +
       		return err

     

       8062
       8062
       +
       	}

     

       8063
       8063
       +
       	return nil

     

       8064
       8064
       +
       }

     

       8065
       8065
       +
       

     

       8066
       8066
       +
       func (t *RepoPull_StackInfo) UnmarshalCBOR(r io.Reader) (err error) {

     

       8067
       8067
       +
       	*t = RepoPull_StackInfo{}

     

       8068
       8068
       +
       

     

       8069
       8069
       +
       	cr := cbg.NewCborReader(r)

     

       8070
       8070
       +
       

     

       8071
       8071
       +
       	maj, extra, err := cr.ReadHeader()

     

       8072
       8072
       +
       	if err != nil {

     

       8073
       8073
       +
       		return err

     

       8074
       8074
       +
       	}

     

       8075
       8075
       +
       	defer func() {

     

       8076
       8076
       +
       		if err == io.EOF {

     

       8077
       8077
       +
       			err = io.ErrUnexpectedEOF

     

       8078
       8078
       +
       		}

     

       8079
       8079
       +
       	}()

     

       8080
       8080
       +
       

     

       8081
       8081
       +
       	if maj != cbg.MajMap {

     

       8082
       8082
       +
       		return fmt.Errorf("cbor input should be of type map")

     

       8083
       8083
       +
       	}

     

       8084
       8084
       +
       

     

       8085
       8085
       +
       	if extra > cbg.MaxLength {

     

       8086
       8086
       +
       		return fmt.Errorf("RepoPull_StackInfo: map struct too large (%d)", extra)

     

       8087
       8087
       +
       	}

     

       8088
       8088
       +
       

     

       8089
       8089
       +
       	n := extra

     

       8090
       8090
       +
       

     

       8091
       8091
       +
       	nameBuf := make([]byte, 8)

     

       8092
       8092
       +
       	for i := uint64(0); i < n; i++ {

     

       8093
       8093
       +
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       8094
       8094
       +
       		if err != nil {

     

       8095
       8095
       +
       			return err

     

       8096
       8096
       +
       		}

     

       8097
       8097
       +
       

     

       8098
       8098
       +
       		if !ok {

     

       8099
       8099
       +
       			// Field doesn't exist on this type, so ignore it

     

       8100
       8100
       +
       			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {

     

       8101
       8101
       +
       				return err

     

       8102
       8102
       +
       			}

     

       8103
       8103
       +
       			continue

     

       8104
       8104
       +
       		}

     

       8105
       8105
       +
       

     

       8106
       8106
       +
       		switch string(nameBuf[:nameLen]) {

     

       8107
       8107
       +
       		// t.Parent (string) (string)

     

       8108
       8108
       +
       		case "parent":

     

       8109
       8109
       +
       

     

       8110
       8110
       +
       			{

     

       8111
       8111
       +
       				b, err := cr.ReadByte()

     

       8112
       8112
       +
       				if err != nil {

     

       8113
       8113
       +
       					return err

     

       8114
       8114
       +
       				}

     

       8115
       8115
       +
       				if b != cbg.CborNull[0] {

     

       8116
       8116
       +
       					if err := cr.UnreadByte(); err != nil {

     

       8117
       8117
       +
       						return err

     

       8118
       8118
       +
       					}

     

       8119
       8119
       +
       

     

       8120
       8120
       +
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       8121
       8121
       +
       					if err != nil {

     

       8122
       8122
       +
       						return err

     

       8123
       8123
       +
       					}

     

       8124
       8124
       +
       

     

       8125
       8125
       +
       					t.Parent = (*string)(&sval)

     

       8126
       8126
       +
       				}

     

       8127
       8127
       +
       			}

     

       8128
       8128
       +
       			// t.ChangeId (string) (string)

     

       8129
       8129
       +
       		case "changeId":

     

       8130
       8130
       +
       

     

       8131
       8131
       +
       			{

     

       8132
       8132
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       8133
       8133
       +
       				if err != nil {

     

       8134
       8134
       +
       					return err

     

       8135
       8135
       +
       				}

     

       8136
       8136
       +
       

     

       8137
       8137
       +
       				t.ChangeId = string(sval)

     

       8138
       8138
       +
       			}

     

       8139
       8139
       +
       

     

       8140
       8140
       +
       		default:

     

       8141
       8141
       +
       			// Field doesn't exist on this type, so ignore it

     

       8142
       8142
       +
       			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {

     

       8143
       8143
       +
       				return err

     

       8144
       8144
       +
       			}

     

       8145
       8145
       +
       		}

     

       8146
       8146
       +
       	}

     

       8147
       8147
       +
       

     

       8148
       8148
       +
       	return nil

     

       8149
       8149
       +
       }

     

       7949
       8150
        
       func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {

     

       7950
       8151
        
       	if t == nil {

     

       7951
       8152
        
       		_, err := w.Write(cbg.CborNull)

+16 -7

api/tangled/repopull.go

···

       17
       17
        
       } //

     

       18
       18
        
       // RECORDTYPE: RepoPull

     

       19
       19
        
       type RepoPull struct {

     

       20
       20
       -
       	LexiconTypeID string           `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`

     

       21
       21
       -
       	Body          *string          `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       -
       	CreatedAt     string           `json:"createdAt" cborgen:"createdAt"`

     

       23
       23
       -
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
       24
       -
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       25
       -
       	Target        *RepoPull_Target `json:"target" cborgen:"target"`

     

       26
       26
       -
       	Title         string           `json:"title" cborgen:"title"`

     

       20
       20
       +
       	LexiconTypeID string              `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`

     

       21
       21
       +
       	Body          *string             `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       +
       	CreatedAt     string              `json:"createdAt" cborgen:"createdAt"`

     

       23
       23
       +
       	Patch         string              `json:"patch" cborgen:"patch"`

     

       24
       24
       +
       	Source        *RepoPull_Source    `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       25
       +
       	StackInfo     *RepoPull_StackInfo `json:"stackInfo,omitempty" cborgen:"stackInfo,omitempty"`

     

       26
       26
       +
       	Target        *RepoPull_Target    `json:"target" cborgen:"target"`

     

       27
       27
       +
       	Title         string              `json:"title" cborgen:"title"`

     

       27
       28
        
       }

     

       28
       29
        
       

     

       29
       30
        
       // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.

     
···

       33
       34
        
       	Sha    string  `json:"sha" cborgen:"sha"`

     

       34
       35
        
       }

     

       35
       36
        
       

     

       37
       37
       +
       // RepoPull_StackInfo is a "stackInfo" in the sh.tangled.repo.pull schema.

     

       38
       38
       +
       type RepoPull_StackInfo struct {

     

       39
       39
       +
       	// changeId: Change ID of this commit/change.

     

       40
       40
       +
       	ChangeId string `json:"changeId" cborgen:"changeId"`

     

       41
       41
       +
       	// parent: AT-URI of the PR for the parent commit/change in the change stack.

     

       42
       42
       +
       	Parent *string `json:"parent,omitempty" cborgen:"parent,omitempty"`

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       36
       45
        
       // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.

     

       37
       46
        
       type RepoPull_Target struct {

     

       38
       47
        
       	Branch string `json:"branch" cborgen:"branch"`

+7

appview/db/db.go

···

       1094
       1094
        
       	})

     

       1095
       1095
        
       	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       1096
       1096
        
       

     

       1097
       1097
       +
       	runMigration(conn, "add-parent-at-for-stacks-to-pulls", func(tx *sql.Tx) error {

     

       1098
       1098
       +
       		_, err := tx.Exec(`

     

       1099
       1099
       +
       			alter table pulls add column parent_at text;

     

       1100
       1100
       +
       		`)

     

       1101
       1101
       +
       		return err

     

       1102
       1102
       +
       	})

     

       1103
       1103
       +
       

     

       1097
       1104
        
       	return &DB{db}, nil

     

       1098
       1105
        
       }

     

       1099
       1106

+17 -4

appview/db/pulls.go

···

       47
       47
        
       		}

     

       48
       48
        
       	}

     

       49
       49
        
       

     

       50
       50
       -
       	var stackId, changeId, parentChangeId *string

     

       50
       50
       +
       	var stackId, changeId, parentAt, parentChangeId *string

     

       51
       51
        
       	if pull.StackId != "" {

     

       52
       52
        
       		stackId = &pull.StackId

     

       53
       53
        
       	}

     

       54
       54
        
       	if pull.ChangeId != "" {

     

       55
       55
        
       		changeId = &pull.ChangeId

     

       56
       56
        
       	}

     

       57
       57
       +
       	if pull.ParentAt != nil {

     

       58
       58
       +
       		parentAt = (*string)(pull.ParentAt)

     

       59
       59
       +
       	}

     

       57
       60
        
       	if pull.ParentChangeId != "" {

     

       58
       61
        
       		parentChangeId = &pull.ParentChangeId

     

       59
       62
        
       	}

     
···

       61
       64
        
       	result, err := tx.Exec(

     

       62
       65
        
       		`

     

       63
       66
        
       		insert into pulls (

     

       64
       64
       -
       			repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_change_id

     

       67
       67
       +
       			repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_at, parent_change_id

     

       65
       68
        
       		)

     

       66
       66
       -
       		values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       69
       69
       +
       		values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       67
       70
        
       		pull.RepoAt,

     

       68
       71
        
       		pull.OwnerDid,

     

       69
       72
        
       		pull.PullId,

     
···

       76
       79
        
       		sourceRepoAt,

     

       77
       80
        
       		stackId,

     

       78
       81
        
       		changeId,

     

       82
       82
       +
       		parentAt,

     

       79
       83
        
       		parentChangeId,

     

       80
       84
        
       	)

     

       81
       85
        
       	if err != nil {

     
···

       145
       149
        
       			source_repo_at,

     

       146
       150
        
       			stack_id,

     

       147
       151
        
       			change_id,

     

       152
       152
       +
       			parent_at,

     

       148
       153
        
       			parent_change_id

     

       149
       154
        
       		from

     

       150
       155
        
       			pulls

     
···

       163
       168
        
       	for rows.Next() {

     

       164
       169
        
       		var pull models.Pull

     

       165
       170
        
       		var createdAt string

     

       166
       166
       -
       		var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       171
       171
       +
       		var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString

     

       167
       172
        
       		err := rows.Scan(

     

       168
       173
        
       			&pull.ID,

     

       169
       174
        
       			&pull.OwnerDid,

     
···

       179
       184
        
       			&sourceRepoAt,

     

       180
       185
        
       			&stackId,

     

       181
       186
        
       			&changeId,

     

       187
       187
       +
       			&parentAt,

     

       182
       188
        
       			&parentChangeId,

     

       183
       189
        
       		)

     

       184
       190
        
       		if err != nil {

     
···

       210
       216
        
       		if changeId.Valid {

     

       211
       217
        
       			pull.ChangeId = changeId.String

     

       212
       218
        
       		}

     

       219
       219
       +
       		if parentAt.Valid {

     

       220
       220
       +
       			parentAtParsed, err := syntax.ParseATURI(parentAt.String)

     

       221
       221
       +
       			if err != nil {

     

       222
       222
       +
       				return nil, err

     

       223
       223
       +
       			}

     

       224
       224
       +
       			pull.ParentAt = &parentAtParsed

     

       225
       225
       +
       		}

     

       213
       226
        
       		if parentChangeId.Valid {

     

       214
       227
        
       			pull.ParentChangeId = parentChangeId.String

     

       215
       228
        
       		}

+5

appview/models/pull.go

···

       70
       70
        
       	// stacking

     

       71
       71
        
       	StackId        string // nullable string

     

       72
       72
        
       	ChangeId       string // nullable string

     

       73
       73
       +
       	ParentAt       *syntax.ATURI

     

       73
       74
        
       	ParentChangeId string // nullable string

     

       74
       75
        
       

     

       75
       76
        
       	// meta

     
···

       99
       100
        
       		},

     

       100
       101
        
       		Patch:  p.LatestPatch(),

     

       101
       102
        
       		Source: source,

     

       103
       103
       +
       		StackInfo: &tangled.RepoPull_StackInfo{

     

       104
       104
       +
       			ChangeId: p.ChangeId,

     

       105
       105
       +
       			Parent: (*string)(p.ParentAt),

     

       106
       106
       +
       		},

     

       102
       107
        
       	}

     

       103
       108
        
       	return record

     

       104
       109
        
       }

+24 -2

appview/pulls/pulls.go

···

       29
       29
        
       

     

       30
       30
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       31
       31
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       32
       32
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       32
       33
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       33
       34
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       34
       35
        
       	"github.com/go-chi/chi/v5"

     
···

       1836
       1837
        
       	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1837
       1838
        
       	if err != nil {

     

       1838
       1839
        
       		log.Println("failed to create resubmitted stack", err)

     

       1839
       1839
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1840
       1840
       +
       		s.pages.Notice(w, "pull-resubmit-error", "Failed to merge pull request. Try again later.")

     

       1840
       1841
        
       		return

     

       1841
       1842
        
       	}

     

       1842
       1843
        
       

     

       1843
       1844
        
       	// find the diff between the stacks, first, map them by changeId

     

       1845
       1845
       +
       

     

       1844
       1846
        
       	origById := make(map[string]*models.Pull)

     

       1845
       1847
        
       	newById := make(map[string]*models.Pull)

     

       1848
       1848
       +
       	chIdToAtUri := make(map[string]*syntax.ATURI)

     

       1849
       1849
       +
       

     

       1846
       1850
        
       	for _, p := range origStack {

     

       1847
       1851
        
       		origById[p.ChangeId] = p

     

       1852
       1852
       +
       

     

       1853
       1853
       +
       		// build map from change id to existing at uris (ignore error as it shouldnt be possible here)

     

       1854
       1854
       +
       		pAtUri, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey))

     

       1855
       1855
       +
       		chIdToAtUri[p.ChangeId] = &pAtUri

     

       1848
       1856
        
       	}

     

       1849
       1857
        
       	for _, p := range newStack {

     

       1858
       1858
       +
       		// if change id has already been given a PR use its at uri instead of the newly created (and thus incorrect)

     

       1859
       1859
       +
       		// one made by newStack

     

       1860
       1860
       +
       		if ppAt, ok := chIdToAtUri[p.ParentChangeId]; ok {

     

       1861
       1861
       +
       			p.ParentAt = ppAt

     

       1862
       1862
       +
       		}

     

       1863
       1863
       +
       

     

       1850
       1864
        
       		newById[p.ChangeId] = p

     

       1851
       1865
        
       	}

     

       1852
       1866
        
       

     
···

       1894
       1908
        
       			// we still need to update the hash in submission.Patch and submission.SourceRev

     

       1895
       1909
        
       			if patchutil.Equal(newFiles, origFiles) &&

     

       1896
       1910
        
       				origHeader.Title == newHeader.Title &&

     

       1897
       1897
       -
       				origHeader.Body == newHeader.Body {

     

       1911
       1911
       +
       				origHeader.Body == newHeader.Body &&

     

       1912
       1912
       +
       				op.ParentChangeId == np.ParentChangeId {

     

       1898
       1913
        
       				unchanged[op.ChangeId] = struct{}{}

     

       1899
       1914
        
       			} else {

     

       1900
       1915
        
       				updated[op.ChangeId] = struct{}{}

     
···

       1978
       1993
        
       

     

       1979
       1994
        
       		record := op.AsRecord()

     

       1980
       1995
        
       		record.Patch = submission.Patch

     

       1996
       1996
       +
       		record.StackInfo.Parent = (*string)(np.ParentAt)

     

       1981
       1997
        
       

     

       1982
       1998
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1983
       1999
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     
···

       2343
       2359
        
       	// the stack is identified by a UUID

     

       2344
       2360
        
       	var stack models.Stack

     

       2345
       2361
        
       	parentChangeId := ""

     

       2362
       2362
       +
       	var parentAt *syntax.ATURI = nil

     

       2346
       2363
        
       	for _, fp := range formatPatches {

     

       2347
       2364
        
       		//  all patches must have a jj change-id

     

       2348
       2365
        
       		changeId, err := fp.ChangeId()

     
···

       2373
       2390
        
       

     

       2374
       2391
        
       			StackId:        stackId,

     

       2375
       2392
        
       			ChangeId:       changeId,

     

       2393
       2393
       +
       			ParentAt:       parentAt,

     

       2376
       2394
        
       			ParentChangeId: parentChangeId,

     

       2377
       2395
        
       		}

     

       2378
       2396
        
       

     

       2379
       2397
        
       		stack = append(stack, &pull)

     

       2380
       2398
        
       

     

       2381
       2399
        
       		parentChangeId = changeId

     

       2400
       2400
       +
       		// this is a bit of an ugly way to create the ATURI but its the best we can do with the data flow here

     

       2401
       2401
       +
       		// (igore error as it shouldnt be possible here)

     

       2402
       2402
       +
       		parsedParentAt, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey));

     

       2403
       2403
       +
       		parentAt = &parsedParentAt

     

       2382
       2404
        
       	}

     

       2383
       2405
        
       

     

       2384
       2406
        
       	return stack, nil

+1

cmd/gen.go

···

       49
       49
        
       		tangled.RepoIssueState{},

     

       50
       50
        
       		tangled.RepoPull{},

     

       51
       51
        
       		tangled.RepoPullComment{},

     

       52
       52
       +
       		tangled.RepoPull_StackInfo{},

     

       52
       53
        
       		tangled.RepoPull_Source{},

     

       53
       54
        
       		tangled.RepoPullStatus{},

     

       54
       55
        
       		tangled.RepoPull_Target{},

+96

lexicons/pulls/round.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "lexicon": 1,

     

       3
       3
       +
         "id": "sh.tangled.repo.pull.round",

     

       4
       4
       +
         "needsCbor": true,

     

       5
       5
       +
         "needsType": true,

     

       6
       6
       +
         "defs": {

     

       7
       7
       +
           "main": {

     

       8
       8
       +
             "type": "record",

     

       9
       9
       +
             "key": "tid",

     

       10
       10
       +
             "record": {

     

       11
       11
       +
               "type": "object",

     

       12
       12
       +
               "required": [

     

       13
       13
       +
                 "pull",

     

       14
       14
       +
                 "patch",

     

       15
       15
       +
                 "sourceInfo",

     

       16
       16
       +
                 "createdAt"

     

       17
       17
       +
               ],

     

       18
       18
       +
               "properties": {

     

       19
       19
       +
                 "pull": {

     

       20
       20
       +
                   "type": "string",

     

       21
       21
       +
                   "format": "at-uri"

     

       22
       22
       +
                 },

     

       23
       23
       +
                 "prevRound": {

     

       24
       24
       +
                   "type": "ref",

     

       25
       25
       +
                   "ref": "com.atproto.repo.strongRef"

     

       26
       26
       +
                 },

     

       27
       27
       +
                 "patch": {

     

       28
       28
       +
                   "type": "string",

     

       29
       29
       +
                   "description": "A patch describing this change. Either gotten directly from the user (patch-based PR) or from the knot based on a commit from another repo. The source of the patch and it's potential details are described by sourceInfo"

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "sourceInfo": {

     

       32
       32
       +
                   "type": "union",

     

       33
       33
       +
                   "refs": [

     

       34
       34
       +
                     "#patchSourceInfo",

     

       35
       35
       +
                     "#commitSourceInfo"

     

       36
       36
       +
                   ]

     

       37
       37
       +
                 },

     

       38
       38
       +
                 "stackInfo": {

     

       39
       39
       +
                   "type": "ref",

     

       40
       40
       +
                   "ref": "#stackInfo"

     

       41
       41
       +
                 },

     

       42
       42
       +
                 "comment": {

     

       43
       43
       +
                   "type": "string"

     

       44
       44
       +
                 },

     

       45
       45
       +
                 "createdAt": {

     

       46
       46
       +
                   "type": "string",

     

       47
       47
       +
                   "format": "datetime"

     

       48
       48
       +
                 }

     

       49
       49
       +
               }

     

       50
       50
       +
             }

     

       51
       51
       +
           },

     

       52
       52
       +
           "patchSourceInfo": {

     

       53
       53
       +
             "type": "object",

     

       54
       54
       +
             "properties": {}

     

       55
       55
       +
           },

     

       56
       56
       +
           "commitSourceInfo": {

     

       57
       57
       +
             "type": "object",

     

       58
       58
       +
             "required": [

     

       59
       59
       +
               "repo",

     

       60
       60
       +
               "branch",

     

       61
       61
       +
               "sha"

     

       62
       62
       +
             ],

     

       63
       63
       +
             "properties": {

     

       64
       64
       +
               "repo": {

     

       65
       65
       +
                 "type": "string",

     

       66
       66
       +
                 "format": "uri"

     

       67
       67
       +
               },

     

       68
       68
       +
               "branch": {

     

       69
       69
       +
                 "type": "string"

     

       70
       70
       +
               },

     

       71
       71
       +
               "sha": {

     

       72
       72
       +
                 "type": "string",

     

       73
       73
       +
                 "minLength": 40,

     

       74
       74
       +
                 "maxLength": 40

     

       75
       75
       +
               }

     

       76
       76
       +
             }

     

       77
       77
       +
           },

     

       78
       78
       +
           "stackInfo": {

     

       79
       79
       +
             "type": "object",

     

       80
       80
       +
             "required": [

     

       81
       81
       +
               "changeId"

     

       82
       82
       +
             ],

     

       83
       83
       +
             "properties": {

     

       84
       84
       +
               "changeId": {

     

       85
       85
       +
                 "type": "string",

     

       86
       86
       +
                 "description": "Change ID of this commit/change."

     

       87
       87
       +
               },

     

       88
       88
       +
               "parent": {

     

       89
       89
       +
                 "type": "string",

     

       90
       90
       +
                 "description": "AT-URI of the PR for the parent commit/change in the change stack.",

     

       91
       91
       +
                 "format": "at-uri"

     

       92
       92
       +
               }

     

       93
       93
       +
             }

     

       94
       94
       +
           }

     

       95
       95
       +
         }

     

       96
       96
       +
       }

Compare changes