comparing three-easy-steps and master on julien.rbrt.fr/tangled-core

+8 -6

.air/appview.toml

···

       1
       1
       -
       [build]

     

       2
       2
       -
       cmd = "tailwindcss -i input.css -o ./appview/pages/static/tw.css && go build -o .bin/app ./cmd/appview/main.go"

     

       3
       3
       -
       bin = ";set -o allexport && source .env && set +o allexport; .bin/app"

     

       4
       1
        
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       5
       3
        
       

     

       6
       6
       -
       exclude_regex = [".*_templ.go"]

     

       7
       7
       -
       include_ext = ["go", "templ", "html", "css"]

     

       8
       8
       -
       exclude_dir = ["target", "atrium", "nix"]

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = "go build -o out/appview.out cmd/appview/main.go"

     

       6
       6
       +
       bin = "out/appview.out"

     

       7
       7
       +
       

     

       8
       8
       +
       include_ext = ["go"]

     

       9
       9
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       10
       10
       +
       stop_on_error = true

+11

.air/knot.toml

···

       1
       1
       +
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       3
       3
       +
       

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = 'go build -ldflags "-X tangled.org/core/knotserver.version=$(git describe --tags --long)" -o out/knot.out cmd/knot/main.go'

     

       6
       6
       +
       bin = "out/knot.out"

     

       7
       7
       +
       args_bin = ["server"]

     

       8
       8
       +
       

     

       9
       9
       +
       include_ext = ["go"]

     

       10
       10
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       11
       11
       +
       stop_on_error = true

-7

.air/knotserver.toml

···

       1
       1
       -
       [build]

     

       2
       2
       -
       cmd = 'go build -ldflags "-X tangled.org/core/knotserver.version=$(git describe --tags --long)" -o .bin/knot ./cmd/knot/'

     

       3
       3
       -
       bin = ".bin/knot server"

     

       4
       4
       -
       root = "."

     

       5
       5
       -
       

     

       6
       6
       -
       exclude_regex = [""]

     

       7
       7
       -
       include_ext = ["go", "templ"]

+10

.air/spindle.toml

···

       1
       1
       +
       root = "."

     

       2
       2
       +
       tmp_dir = "out"

     

       3
       3
       +
       

     

       4
       4
       +
       [build]

     

       5
       5
       +
       cmd = "go build -o out/spindle.out cmd/spindle/main.go"

     

       6
       6
       +
       bin = "out/spindle.out"

     

       7
       7
       +
       

     

       8
       8
       +
       include_ext = ["go"]

     

       9
       9
       +
       exclude_dir = ["avatar", "camo", "indexes", "nix", "tmp"]

     

       10
       10
       +
       stop_on_error = true

+13

.editorconfig

···

       1
       1
       +
       root = true

     

       2
       2
       +
       

     

       3
       3
       +
       [*.html]

     

       4
       4
       +
       indent_size = 2

     

       5
       5
       +
       

     

       6
       6
       +
       [*.json]

     

       7
       7
       +
       indent_size = 2

     

       8
       8
       +
       

     

       9
       9
       +
       [*.nix]

     

       10
       10
       +
       indent_size = 2

     

       11
       11
       +
       

     

       12
       12
       +
       [*.yml]

     

       13
       13
       +
       indent_size = 2

.gitignore

···

       15
       15
        
       .env

     

       16
       16
        
       *.rdb

     

       17
       17
        
       .envrc

     

       18
       18
       +
       **/*.bleve

     

       18
       19
        
       # Created if following hacking.md

     

       19
       20
        
       genjwks.out

     

       20
       21
        
       /nix/vm-data

+3 -1

api/tangled/actorprofile.go

···

       27
       27
        
       	Location *string `json:"location,omitempty" cborgen:"location,omitempty"`

     

       28
       28
        
       	// pinnedRepositories: Any ATURI, it is up to appviews to validate these fields.

     

       29
       29
        
       	PinnedRepositories []string `json:"pinnedRepositories,omitempty" cborgen:"pinnedRepositories,omitempty"`

     

       30
       30
       -
       	Stats              []string `json:"stats,omitempty" cborgen:"stats,omitempty"`

     

       30
       30
       +
       	// pronouns: Preferred gender pronouns.

     

       31
       31
       +
       	Pronouns *string  `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"`

     

       32
       32
       +
       	Stats    []string `json:"stats,omitempty" cborgen:"stats,omitempty"`

     

       31
       33
        
       }

+845 -10

api/tangled/cbor_gen.go

···

       26
       26
        
       	}

     

       27
       27
        
       

     

       28
       28
        
       	cw := cbg.NewCborWriter(w)

     

       29
       29
       -
       	fieldCount := 7

     

       29
       29
       +
       	fieldCount := 8

     

       30
       30
        
       

     

       31
       31
        
       	if t.Description == nil {

     

       32
       32
        
       		fieldCount--

     
···

       41
       41
        
       	}

     

       42
       42
        
       

     

       43
       43
        
       	if t.PinnedRepositories == nil {

     

       44
       44
       +
       		fieldCount--

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	if t.Pronouns == nil {

     

       44
       48
        
       		fieldCount--

     

       45
       49
        
       	}

     

       46
       50
        
       

     
···

       186
       190
        
       				return err

     

       187
       191
        
       			}

     

       188
       192
        
       			if _, err := cw.WriteString(string(*t.Location)); err != nil {

     

       193
       193
       +
       				return err

     

       194
       194
       +
       			}

     

       195
       195
       +
       		}

     

       196
       196
       +
       	}

     

       197
       197
       +
       

     

       198
       198
       +
       	// t.Pronouns (string) (string)

     

       199
       199
       +
       	if t.Pronouns != nil {

     

       200
       200
       +
       

     

       201
       201
       +
       		if len("pronouns") > 1000000 {

     

       202
       202
       +
       			return xerrors.Errorf("Value in field \"pronouns\" was too long")

     

       203
       203
       +
       		}

     

       204
       204
       +
       

     

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

     

       206
       206
       +
       			return err

     

       207
       207
       +
       		}

     

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

     

       209
       209
       +
       			return err

     

       210
       210
       +
       		}

     

       211
       211
       +
       

     

       212
       212
       +
       		if t.Pronouns == nil {

     

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

     

       214
       214
       +
       				return err

     

       215
       215
       +
       			}

     

       216
       216
       +
       		} else {

     

       217
       217
       +
       			if len(*t.Pronouns) > 1000000 {

     

       218
       218
       +
       				return xerrors.Errorf("Value in field t.Pronouns was too long")

     

       219
       219
       +
       			}

     

       220
       220
       +
       

     

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

     

       222
       222
       +
       				return err

     

       223
       223
       +
       			}

     

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

     

       189
       225
        
       				return err

     

       190
       226
        
       			}

     

       191
       227
        
       		}

     
···

       430
       466
        
       					}

     

       431
       467
        
       

     

       432
       468
        
       					t.Location = (*string)(&sval)

     

       469
       469
       +
       				}

     

       470
       470
       +
       			}

     

       471
       471
       +
       			// t.Pronouns (string) (string)

     

       472
       472
       +
       		case "pronouns":

     

       473
       473
       +
       

     

       474
       474
       +
       			{

     

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

     

       476
       476
       +
       				if err != nil {

     

       477
       477
       +
       					return err

     

       478
       478
       +
       				}

     

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

     

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

     

       481
       481
       +
       						return err

     

       482
       482
       +
       					}

     

       483
       483
       +
       

     

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

     

       485
       485
       +
       					if err != nil {

     

       486
       486
       +
       						return err

     

       487
       487
       +
       					}

     

       488
       488
       +
       

     

       489
       489
       +
       					t.Pronouns = (*string)(&sval)

     

       433
       490
        
       				}

     

       434
       491
        
       			}

     

       435
       492
        
       			// t.Description (string) (string)

     
···

       5806
       5863
        
       	}

     

       5807
       5864
        
       

     

       5808
       5865
        
       	cw := cbg.NewCborWriter(w)

     

       5809
       5809
       -
       	fieldCount := 8

     

       5866
       5866
       +
       	fieldCount := 10

     

       5810
       5867
        
       

     

       5811
       5868
        
       	if t.Description == nil {

     

       5812
       5869
        
       		fieldCount--

     
···

       5821
       5878
        
       	}

     

       5822
       5879
        
       

     

       5823
       5880
        
       	if t.Spindle == nil {

     

       5881
       5881
       +
       		fieldCount--

     

       5882
       5882
       +
       	}

     

       5883
       5883
       +
       

     

       5884
       5884
       +
       	if t.Topics == nil {

     

       5885
       5885
       +
       		fieldCount--

     

       5886
       5886
       +
       	}

     

       5887
       5887
       +
       

     

       5888
       5888
       +
       	if t.Website == nil {

     

       5824
       5889
        
       		fieldCount--

     

       5825
       5890
        
       	}

     

       5826
       5891
        
       

     
···

       5961
       6026
        
       		}

     

       5962
       6027
        
       	}

     

       5963
       6028
        
       

     

       6029
       6029
       +
       	// t.Topics ([]string) (slice)

     

       6030
       6030
       +
       	if t.Topics != nil {

     

       6031
       6031
       +
       

     

       6032
       6032
       +
       		if len("topics") > 1000000 {

     

       6033
       6033
       +
       			return xerrors.Errorf("Value in field \"topics\" was too long")

     

       6034
       6034
       +
       		}

     

       6035
       6035
       +
       

     

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

     

       6037
       6037
       +
       			return err

     

       6038
       6038
       +
       		}

     

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

     

       6040
       6040
       +
       			return err

     

       6041
       6041
       +
       		}

     

       6042
       6042
       +
       

     

       6043
       6043
       +
       		if len(t.Topics) > 8192 {

     

       6044
       6044
       +
       			return xerrors.Errorf("Slice value in field t.Topics was too long")

     

       6045
       6045
       +
       		}

     

       6046
       6046
       +
       

     

       6047
       6047
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Topics))); err != nil {

     

       6048
       6048
       +
       			return err

     

       6049
       6049
       +
       		}

     

       6050
       6050
       +
       		for _, v := range t.Topics {

     

       6051
       6051
       +
       			if len(v) > 1000000 {

     

       6052
       6052
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       6053
       6053
       +
       			}

     

       6054
       6054
       +
       

     

       6055
       6055
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       6056
       6056
       +
       				return err

     

       6057
       6057
       +
       			}

     

       6058
       6058
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       6059
       6059
       +
       				return err

     

       6060
       6060
       +
       			}

     

       6061
       6061
       +
       

     

       6062
       6062
       +
       		}

     

       6063
       6063
       +
       	}

     

       6064
       6064
       +
       

     

       5964
       6065
        
       	// t.Spindle (string) (string)

     

       5965
       6066
        
       	if t.Spindle != nil {

     

       5966
       6067
        
       

     
···

       5993
       6094
        
       		}

     

       5994
       6095
        
       	}

     

       5995
       6096
        
       

     

       6097
       6097
       +
       	// t.Website (string) (string)

     

       6098
       6098
       +
       	if t.Website != nil {

     

       6099
       6099
       +
       

     

       6100
       6100
       +
       		if len("website") > 1000000 {

     

       6101
       6101
       +
       			return xerrors.Errorf("Value in field \"website\" was too long")

     

       6102
       6102
       +
       		}

     

       6103
       6103
       +
       

     

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

     

       6105
       6105
       +
       			return err

     

       6106
       6106
       +
       		}

     

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

     

       6108
       6108
       +
       			return err

     

       6109
       6109
       +
       		}

     

       6110
       6110
       +
       

     

       6111
       6111
       +
       		if t.Website == nil {

     

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

     

       6113
       6113
       +
       				return err

     

       6114
       6114
       +
       			}

     

       6115
       6115
       +
       		} else {

     

       6116
       6116
       +
       			if len(*t.Website) > 1000000 {

     

       6117
       6117
       +
       				return xerrors.Errorf("Value in field t.Website was too long")

     

       6118
       6118
       +
       			}

     

       6119
       6119
       +
       

     

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

     

       6121
       6121
       +
       				return err

     

       6122
       6122
       +
       			}

     

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

     

       6124
       6124
       +
       				return err

     

       6125
       6125
       +
       			}

     

       6126
       6126
       +
       		}

     

       6127
       6127
       +
       	}

     

       6128
       6128
       +
       

     

       5996
       6129
        
       	// t.CreatedAt (string) (string)

     

       5997
       6130
        
       	if len("createdAt") > 1000000 {

     

       5998
       6131
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       6185
       6318
        
       					t.Source = (*string)(&sval)

     

       6186
       6319
        
       				}

     

       6187
       6320
        
       			}

     

       6321
       6321
       +
       			// t.Topics ([]string) (slice)

     

       6322
       6322
       +
       		case "topics":

     

       6323
       6323
       +
       

     

       6324
       6324
       +
       			maj, extra, err = cr.ReadHeader()

     

       6325
       6325
       +
       			if err != nil {

     

       6326
       6326
       +
       				return err

     

       6327
       6327
       +
       			}

     

       6328
       6328
       +
       

     

       6329
       6329
       +
       			if extra > 8192 {

     

       6330
       6330
       +
       				return fmt.Errorf("t.Topics: array too large (%d)", extra)

     

       6331
       6331
       +
       			}

     

       6332
       6332
       +
       

     

       6333
       6333
       +
       			if maj != cbg.MajArray {

     

       6334
       6334
       +
       				return fmt.Errorf("expected cbor array")

     

       6335
       6335
       +
       			}

     

       6336
       6336
       +
       

     

       6337
       6337
       +
       			if extra > 0 {

     

       6338
       6338
       +
       				t.Topics = make([]string, extra)

     

       6339
       6339
       +
       			}

     

       6340
       6340
       +
       

     

       6341
       6341
       +
       			for i := 0; i < int(extra); i++ {

     

       6342
       6342
       +
       				{

     

       6343
       6343
       +
       					var maj byte

     

       6344
       6344
       +
       					var extra uint64

     

       6345
       6345
       +
       					var err error

     

       6346
       6346
       +
       					_ = maj

     

       6347
       6347
       +
       					_ = extra

     

       6348
       6348
       +
       					_ = err

     

       6349
       6349
       +
       

     

       6350
       6350
       +
       					{

     

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

     

       6352
       6352
       +
       						if err != nil {

     

       6353
       6353
       +
       							return err

     

       6354
       6354
       +
       						}

     

       6355
       6355
       +
       

     

       6356
       6356
       +
       						t.Topics[i] = string(sval)

     

       6357
       6357
       +
       					}

     

       6358
       6358
       +
       

     

       6359
       6359
       +
       				}

     

       6360
       6360
       +
       			}

     

       6188
       6361
        
       			// t.Spindle (string) (string)

     

       6189
       6362
        
       		case "spindle":

     

       6190
       6363
        
       

     
···

       6204
       6377
        
       					}

     

       6205
       6378
        
       

     

       6206
       6379
        
       					t.Spindle = (*string)(&sval)

     

       6380
       6380
       +
       				}

     

       6381
       6381
       +
       			}

     

       6382
       6382
       +
       			// t.Website (string) (string)

     

       6383
       6383
       +
       		case "website":

     

       6384
       6384
       +
       

     

       6385
       6385
       +
       			{

     

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

     

       6387
       6387
       +
       				if err != nil {

     

       6388
       6388
       +
       					return err

     

       6389
       6389
       +
       				}

     

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

     

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

     

       6392
       6392
       +
       						return err

     

       6393
       6393
       +
       					}

     

       6394
       6394
       +
       

     

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

     

       6396
       6396
       +
       					if err != nil {

     

       6397
       6397
       +
       						return err

     

       6398
       6398
       +
       					}

     

       6399
       6399
       +
       

     

       6400
       6400
       +
       					t.Website = (*string)(&sval)

     

       6207
       6401
        
       				}

     

       6208
       6402
        
       			}

     

       6209
       6403
        
       			// t.CreatedAt (string) (string)

     
···

       6744
       6938
        
       	}

     

       6745
       6939
        
       

     

       6746
       6940
        
       	cw := cbg.NewCborWriter(w)

     

       6747
       6747
       -
       	fieldCount := 5

     

       6941
       6941
       +
       	fieldCount := 7

     

       6748
       6942
        
       

     

       6749
       6943
        
       	if t.Body == nil {

     

       6944
       6944
       +
       		fieldCount--

     

       6945
       6945
       +
       	}

     

       6946
       6946
       +
       

     

       6947
       6947
       +
       	if t.Mentions == nil {

     

       6948
       6948
       +
       		fieldCount--

     

       6949
       6949
       +
       	}

     

       6950
       6950
       +
       

     

       6951
       6951
       +
       	if t.References == nil {

     

       6750
       6952
        
       		fieldCount--

     

       6751
       6953
        
       	}

     

       6752
       6954
        
       

     
···

       6851
       7053
        
       		return err

     

       6852
       7054
        
       	}

     

       6853
       7055
        
       

     

       7056
       7056
       +
       	// t.Mentions ([]string) (slice)

     

       7057
       7057
       +
       	if t.Mentions != nil {

     

       7058
       7058
       +
       

     

       7059
       7059
       +
       		if len("mentions") > 1000000 {

     

       7060
       7060
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       7061
       7061
       +
       		}

     

       7062
       7062
       +
       

     

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

     

       7064
       7064
       +
       			return err

     

       7065
       7065
       +
       		}

     

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

     

       7067
       7067
       +
       			return err

     

       7068
       7068
       +
       		}

     

       7069
       7069
       +
       

     

       7070
       7070
       +
       		if len(t.Mentions) > 8192 {

     

       7071
       7071
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       7072
       7072
       +
       		}

     

       7073
       7073
       +
       

     

       7074
       7074
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       7075
       7075
       +
       			return err

     

       7076
       7076
       +
       		}

     

       7077
       7077
       +
       		for _, v := range t.Mentions {

     

       7078
       7078
       +
       			if len(v) > 1000000 {

     

       7079
       7079
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7080
       7080
       +
       			}

     

       7081
       7081
       +
       

     

       7082
       7082
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7083
       7083
       +
       				return err

     

       7084
       7084
       +
       			}

     

       7085
       7085
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7086
       7086
       +
       				return err

     

       7087
       7087
       +
       			}

     

       7088
       7088
       +
       

     

       7089
       7089
       +
       		}

     

       7090
       7090
       +
       	}

     

       7091
       7091
       +
       

     

       6854
       7092
        
       	// t.CreatedAt (string) (string)

     

       6855
       7093
        
       	if len("createdAt") > 1000000 {

     

       6856
       7094
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       6874
       7112
        
       		return err

     

       6875
       7113
        
       	}

     

       7114
       7114
       +
       

     

       7115
       7115
       +
       	// t.References ([]string) (slice)

     

       7116
       7116
       +
       	if t.References != nil {

     

       7117
       7117
       +
       

     

       7118
       7118
       +
       		if len("references") > 1000000 {

     

       7119
       7119
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       7120
       7120
       +
       		}

     

       7121
       7121
       +
       

     

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

     

       7123
       7123
       +
       			return err

     

       7124
       7124
       +
       		}

     

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

     

       7126
       7126
       +
       			return err

     

       7127
       7127
       +
       		}

     

       7128
       7128
       +
       

     

       7129
       7129
       +
       		if len(t.References) > 8192 {

     

       7130
       7130
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       7131
       7131
       +
       		}

     

       7132
       7132
       +
       

     

       7133
       7133
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       7134
       7134
       +
       			return err

     

       7135
       7135
       +
       		}

     

       7136
       7136
       +
       		for _, v := range t.References {

     

       7137
       7137
       +
       			if len(v) > 1000000 {

     

       7138
       7138
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7139
       7139
       +
       			}

     

       7140
       7140
       +
       

     

       7141
       7141
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7142
       7142
       +
       				return err

     

       7143
       7143
       +
       			}

     

       7144
       7144
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7145
       7145
       +
       				return err

     

       7146
       7146
       +
       			}

     

       7147
       7147
       +
       

     

       7148
       7148
       +
       		}

     

       7149
       7149
       +
       	}

     

       6876
       7150
        
       	return nil

     

       6877
       7151
        
       }

     

       6878
       7152
        
       

     
···

       6901
       7175
        
       

     

       6902
       7176
        
       	n := extra

     

       6903
       7177
        
       

     

       6904
       6904
       -
       	nameBuf := make([]byte, 9)

     

       7178
       7178
       +
       	nameBuf := make([]byte, 10)

     

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

     

       6906
       7180
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       6907
       7181
        
       		if err != nil {

     
···

       6971
       7245
        
       

     

       6972
       7246
        
       				t.Title = string(sval)

     

       6973
       7247
        
       			}

     

       7248
       7248
       +
       			// t.Mentions ([]string) (slice)

     

       7249
       7249
       +
       		case "mentions":

     

       7250
       7250
       +
       

     

       7251
       7251
       +
       			maj, extra, err = cr.ReadHeader()

     

       7252
       7252
       +
       			if err != nil {

     

       7253
       7253
       +
       				return err

     

       7254
       7254
       +
       			}

     

       7255
       7255
       +
       

     

       7256
       7256
       +
       			if extra > 8192 {

     

       7257
       7257
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       7258
       7258
       +
       			}

     

       7259
       7259
       +
       

     

       7260
       7260
       +
       			if maj != cbg.MajArray {

     

       7261
       7261
       +
       				return fmt.Errorf("expected cbor array")

     

       7262
       7262
       +
       			}

     

       7263
       7263
       +
       

     

       7264
       7264
       +
       			if extra > 0 {

     

       7265
       7265
       +
       				t.Mentions = make([]string, extra)

     

       7266
       7266
       +
       			}

     

       7267
       7267
       +
       

     

       7268
       7268
       +
       			for i := 0; i < int(extra); i++ {

     

       7269
       7269
       +
       				{

     

       7270
       7270
       +
       					var maj byte

     

       7271
       7271
       +
       					var extra uint64

     

       7272
       7272
       +
       					var err error

     

       7273
       7273
       +
       					_ = maj

     

       7274
       7274
       +
       					_ = extra

     

       7275
       7275
       +
       					_ = err

     

       7276
       7276
       +
       

     

       7277
       7277
       +
       					{

     

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

     

       7279
       7279
       +
       						if err != nil {

     

       7280
       7280
       +
       							return err

     

       7281
       7281
       +
       						}

     

       7282
       7282
       +
       

     

       7283
       7283
       +
       						t.Mentions[i] = string(sval)

     

       7284
       7284
       +
       					}

     

       7285
       7285
       +
       

     

       7286
       7286
       +
       				}

     

       7287
       7287
       +
       			}

     

       6974
       7288
        
       			// t.CreatedAt (string) (string)

     

       6975
       7289
        
       		case "createdAt":

     

       6976
       7290
        
       

     
···

       6981
       7295
        
       				}

     

       6982
       7296
        
       

     

       6983
       7297
        
       				t.CreatedAt = string(sval)

     

       7298
       7298
       +
       			}

     

       7299
       7299
       +
       			// t.References ([]string) (slice)

     

       7300
       7300
       +
       		case "references":

     

       7301
       7301
       +
       

     

       7302
       7302
       +
       			maj, extra, err = cr.ReadHeader()

     

       7303
       7303
       +
       			if err != nil {

     

       7304
       7304
       +
       				return err

     

       7305
       7305
       +
       			}

     

       7306
       7306
       +
       

     

       7307
       7307
       +
       			if extra > 8192 {

     

       7308
       7308
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       7309
       7309
       +
       			}

     

       7310
       7310
       +
       

     

       7311
       7311
       +
       			if maj != cbg.MajArray {

     

       7312
       7312
       +
       				return fmt.Errorf("expected cbor array")

     

       7313
       7313
       +
       			}

     

       7314
       7314
       +
       

     

       7315
       7315
       +
       			if extra > 0 {

     

       7316
       7316
       +
       				t.References = make([]string, extra)

     

       7317
       7317
       +
       			}

     

       7318
       7318
       +
       

     

       7319
       7319
       +
       			for i := 0; i < int(extra); i++ {

     

       7320
       7320
       +
       				{

     

       7321
       7321
       +
       					var maj byte

     

       7322
       7322
       +
       					var extra uint64

     

       7323
       7323
       +
       					var err error

     

       7324
       7324
       +
       					_ = maj

     

       7325
       7325
       +
       					_ = extra

     

       7326
       7326
       +
       					_ = err

     

       7327
       7327
       +
       

     

       7328
       7328
       +
       					{

     

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

     

       7330
       7330
       +
       						if err != nil {

     

       7331
       7331
       +
       							return err

     

       7332
       7332
       +
       						}

     

       7333
       7333
       +
       

     

       7334
       7334
       +
       						t.References[i] = string(sval)

     

       7335
       7335
       +
       					}

     

       7336
       7336
       +
       

     

       7337
       7337
       +
       				}

     

       6984
       7338
        
       			}

     

       6985
       7339
        
       

     

       6986
       7340
        
       		default:

     
···

       7000
       7354
        
       	}

     

       7001
       7355
        
       

     

       7002
       7356
        
       	cw := cbg.NewCborWriter(w)

     

       7003
       7003
       -
       	fieldCount := 5

     

       7357
       7357
       +
       	fieldCount := 7

     

       7358
       7358
       +
       

     

       7359
       7359
       +
       	if t.Mentions == nil {

     

       7360
       7360
       +
       		fieldCount--

     

       7361
       7361
       +
       	}

     

       7362
       7362
       +
       

     

       7363
       7363
       +
       	if t.References == nil {

     

       7364
       7364
       +
       		fieldCount--

     

       7365
       7365
       +
       	}

     

       7004
       7366
        
       

     

       7005
       7367
        
       	if t.ReplyTo == nil {

     

       7006
       7368
        
       		fieldCount--

     
···

       7104
       7466
        
       			if _, err := cw.WriteString(string(*t.ReplyTo)); err != nil {

     

       7105
       7467
        
       				return err

     

       7106
       7468
        
       			}

     

       7469
       7469
       +
       		}

     

       7470
       7470
       +
       	}

     

       7471
       7471
       +
       

     

       7472
       7472
       +
       	// t.Mentions ([]string) (slice)

     

       7473
       7473
       +
       	if t.Mentions != nil {

     

       7474
       7474
       +
       

     

       7475
       7475
       +
       		if len("mentions") > 1000000 {

     

       7476
       7476
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       7477
       7477
       +
       		}

     

       7478
       7478
       +
       

     

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

     

       7480
       7480
       +
       			return err

     

       7481
       7481
       +
       		}

     

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

     

       7483
       7483
       +
       			return err

     

       7484
       7484
       +
       		}

     

       7485
       7485
       +
       

     

       7486
       7486
       +
       		if len(t.Mentions) > 8192 {

     

       7487
       7487
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       7488
       7488
       +
       		}

     

       7489
       7489
       +
       

     

       7490
       7490
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       7491
       7491
       +
       			return err

     

       7492
       7492
       +
       		}

     

       7493
       7493
       +
       		for _, v := range t.Mentions {

     

       7494
       7494
       +
       			if len(v) > 1000000 {

     

       7495
       7495
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7496
       7496
       +
       			}

     

       7497
       7497
       +
       

     

       7498
       7498
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7499
       7499
       +
       				return err

     

       7500
       7500
       +
       			}

     

       7501
       7501
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7502
       7502
       +
       				return err

     

       7503
       7503
       +
       			}

     

       7504
       7504
       +
       

     

       7107
       7505
        
       		}

     

       7108
       7506
        
       	}

     

       7109
       7507
        
       

     
···

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

     

       7130
       7528
        
       		return err

     

       7131
       7529
        
       	}

     

       7530
       7530
       +
       

     

       7531
       7531
       +
       	// t.References ([]string) (slice)

     

       7532
       7532
       +
       	if t.References != nil {

     

       7533
       7533
       +
       

     

       7534
       7534
       +
       		if len("references") > 1000000 {

     

       7535
       7535
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       7536
       7536
       +
       		}

     

       7537
       7537
       +
       

     

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

     

       7539
       7539
       +
       			return err

     

       7540
       7540
       +
       		}

     

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

     

       7542
       7542
       +
       			return err

     

       7543
       7543
       +
       		}

     

       7544
       7544
       +
       

     

       7545
       7545
       +
       		if len(t.References) > 8192 {

     

       7546
       7546
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       7547
       7547
       +
       		}

     

       7548
       7548
       +
       

     

       7549
       7549
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       7550
       7550
       +
       			return err

     

       7551
       7551
       +
       		}

     

       7552
       7552
       +
       		for _, v := range t.References {

     

       7553
       7553
       +
       			if len(v) > 1000000 {

     

       7554
       7554
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7555
       7555
       +
       			}

     

       7556
       7556
       +
       

     

       7557
       7557
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7558
       7558
       +
       				return err

     

       7559
       7559
       +
       			}

     

       7560
       7560
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7561
       7561
       +
       				return err

     

       7562
       7562
       +
       			}

     

       7563
       7563
       +
       

     

       7564
       7564
       +
       		}

     

       7565
       7565
       +
       	}

     

       7132
       7566
        
       	return nil

     

       7133
       7567
        
       }

     

       7134
       7568
        
       

     
···

       7157
       7591
        
       

     

       7158
       7592
        
       	n := extra

     

       7159
       7593
        
       

     

       7160
       7160
       -
       	nameBuf := make([]byte, 9)

     

       7594
       7594
       +
       	nameBuf := make([]byte, 10)

     

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

     

       7162
       7596
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       7163
       7597
        
       		if err != nil {

     
···

       7227
       7661
        
       					t.ReplyTo = (*string)(&sval)

     

       7228
       7662
        
       				}

     

       7229
       7663
        
       			}

     

       7664
       7664
       +
       			// t.Mentions ([]string) (slice)

     

       7665
       7665
       +
       		case "mentions":

     

       7666
       7666
       +
       

     

       7667
       7667
       +
       			maj, extra, err = cr.ReadHeader()

     

       7668
       7668
       +
       			if err != nil {

     

       7669
       7669
       +
       				return err

     

       7670
       7670
       +
       			}

     

       7671
       7671
       +
       

     

       7672
       7672
       +
       			if extra > 8192 {

     

       7673
       7673
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       7674
       7674
       +
       			}

     

       7675
       7675
       +
       

     

       7676
       7676
       +
       			if maj != cbg.MajArray {

     

       7677
       7677
       +
       				return fmt.Errorf("expected cbor array")

     

       7678
       7678
       +
       			}

     

       7679
       7679
       +
       

     

       7680
       7680
       +
       			if extra > 0 {

     

       7681
       7681
       +
       				t.Mentions = make([]string, extra)

     

       7682
       7682
       +
       			}

     

       7683
       7683
       +
       

     

       7684
       7684
       +
       			for i := 0; i < int(extra); i++ {

     

       7685
       7685
       +
       				{

     

       7686
       7686
       +
       					var maj byte

     

       7687
       7687
       +
       					var extra uint64

     

       7688
       7688
       +
       					var err error

     

       7689
       7689
       +
       					_ = maj

     

       7690
       7690
       +
       					_ = extra

     

       7691
       7691
       +
       					_ = err

     

       7692
       7692
       +
       

     

       7693
       7693
       +
       					{

     

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

     

       7695
       7695
       +
       						if err != nil {

     

       7696
       7696
       +
       							return err

     

       7697
       7697
       +
       						}

     

       7698
       7698
       +
       

     

       7699
       7699
       +
       						t.Mentions[i] = string(sval)

     

       7700
       7700
       +
       					}

     

       7701
       7701
       +
       

     

       7702
       7702
       +
       				}

     

       7703
       7703
       +
       			}

     

       7230
       7704
        
       			// t.CreatedAt (string) (string)

     

       7231
       7705
        
       		case "createdAt":

     

       7232
       7706
        
       

     
···

       7238
       7712
        
       

     

       7239
       7713
        
       				t.CreatedAt = string(sval)

     

       7240
       7714
        
       			}

     

       7715
       7715
       +
       			// t.References ([]string) (slice)

     

       7716
       7716
       +
       		case "references":

     

       7717
       7717
       +
       

     

       7718
       7718
       +
       			maj, extra, err = cr.ReadHeader()

     

       7719
       7719
       +
       			if err != nil {

     

       7720
       7720
       +
       				return err

     

       7721
       7721
       +
       			}

     

       7722
       7722
       +
       

     

       7723
       7723
       +
       			if extra > 8192 {

     

       7724
       7724
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       7725
       7725
       +
       			}

     

       7726
       7726
       +
       

     

       7727
       7727
       +
       			if maj != cbg.MajArray {

     

       7728
       7728
       +
       				return fmt.Errorf("expected cbor array")

     

       7729
       7729
       +
       			}

     

       7730
       7730
       +
       

     

       7731
       7731
       +
       			if extra > 0 {

     

       7732
       7732
       +
       				t.References = make([]string, extra)

     

       7733
       7733
       +
       			}

     

       7734
       7734
       +
       

     

       7735
       7735
       +
       			for i := 0; i < int(extra); i++ {

     

       7736
       7736
       +
       				{

     

       7737
       7737
       +
       					var maj byte

     

       7738
       7738
       +
       					var extra uint64

     

       7739
       7739
       +
       					var err error

     

       7740
       7740
       +
       					_ = maj

     

       7741
       7741
       +
       					_ = extra

     

       7742
       7742
       +
       					_ = err

     

       7743
       7743
       +
       

     

       7744
       7744
       +
       					{

     

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

     

       7746
       7746
       +
       						if err != nil {

     

       7747
       7747
       +
       							return err

     

       7748
       7748
       +
       						}

     

       7749
       7749
       +
       

     

       7750
       7750
       +
       						t.References[i] = string(sval)

     

       7751
       7751
       +
       					}

     

       7752
       7752
       +
       

     

       7753
       7753
       +
       				}

     

       7754
       7754
       +
       			}

     

       7241
       7755
        
       

     

       7242
       7756
        
       		default:

     

       7243
       7757
        
       			// Field doesn't exist on this type, so ignore it

     
···

       7420
       7934
        
       	}

     

       7421
       7935
        
       

     

       7422
       7936
        
       	cw := cbg.NewCborWriter(w)

     

       7423
       7423
       -
       	fieldCount := 7

     

       7937
       7937
       +
       	fieldCount := 9

     

       7424
       7938
        
       

     

       7425
       7939
        
       	if t.Body == nil {

     

       7426
       7940
        
       		fieldCount--

     

       7427
       7941
        
       	}

     

       7428
       7942
        
       

     

       7943
       7943
       +
       	if t.Mentions == nil {

     

       7944
       7944
       +
       		fieldCount--

     

       7945
       7945
       +
       	}

     

       7946
       7946
       +
       

     

       7947
       7947
       +
       	if t.References == nil {

     

       7948
       7948
       +
       		fieldCount--

     

       7949
       7949
       +
       	}

     

       7950
       7950
       +
       

     

       7429
       7951
        
       	if t.Source == nil {

     

       7430
       7952
        
       		fieldCount--

     

       7431
       7953
        
       	}

     
···

       7566
       8088
        
       		return err

     

       7567
       8089
        
       	}

     

       7568
       8090
        
       

     

       8091
       8091
       +
       	// t.Mentions ([]string) (slice)

     

       8092
       8092
       +
       	if t.Mentions != nil {

     

       8093
       8093
       +
       

     

       8094
       8094
       +
       		if len("mentions") > 1000000 {

     

       8095
       8095
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       8096
       8096
       +
       		}

     

       8097
       8097
       +
       

     

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

     

       8099
       8099
       +
       			return err

     

       8100
       8100
       +
       		}

     

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

     

       8102
       8102
       +
       			return err

     

       8103
       8103
       +
       		}

     

       8104
       8104
       +
       

     

       8105
       8105
       +
       		if len(t.Mentions) > 8192 {

     

       8106
       8106
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       8107
       8107
       +
       		}

     

       8108
       8108
       +
       

     

       8109
       8109
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       8110
       8110
       +
       			return err

     

       8111
       8111
       +
       		}

     

       8112
       8112
       +
       		for _, v := range t.Mentions {

     

       8113
       8113
       +
       			if len(v) > 1000000 {

     

       8114
       8114
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8115
       8115
       +
       			}

     

       8116
       8116
       +
       

     

       8117
       8117
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8118
       8118
       +
       				return err

     

       8119
       8119
       +
       			}

     

       8120
       8120
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8121
       8121
       +
       				return err

     

       8122
       8122
       +
       			}

     

       8123
       8123
       +
       

     

       8124
       8124
       +
       		}

     

       8125
       8125
       +
       	}

     

       8126
       8126
       +
       

     

       7569
       8127
        
       	// t.CreatedAt (string) (string)

     

       7570
       8128
        
       	if len("createdAt") > 1000000 {

     

       7571
       8129
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       7589
       8147
        
       		return err

     

       7590
       8148
        
       	}

     

       8149
       8149
       +
       

     

       8150
       8150
       +
       	// t.References ([]string) (slice)

     

       8151
       8151
       +
       	if t.References != nil {

     

       8152
       8152
       +
       

     

       8153
       8153
       +
       		if len("references") > 1000000 {

     

       8154
       8154
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       8155
       8155
       +
       		}

     

       8156
       8156
       +
       

     

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

     

       8158
       8158
       +
       			return err

     

       8159
       8159
       +
       		}

     

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

     

       8161
       8161
       +
       			return err

     

       8162
       8162
       +
       		}

     

       8163
       8163
       +
       

     

       8164
       8164
       +
       		if len(t.References) > 8192 {

     

       8165
       8165
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       8166
       8166
       +
       		}

     

       8167
       8167
       +
       

     

       8168
       8168
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       8169
       8169
       +
       			return err

     

       8170
       8170
       +
       		}

     

       8171
       8171
       +
       		for _, v := range t.References {

     

       8172
       8172
       +
       			if len(v) > 1000000 {

     

       8173
       8173
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8174
       8174
       +
       			}

     

       8175
       8175
       +
       

     

       8176
       8176
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8177
       8177
       +
       				return err

     

       8178
       8178
       +
       			}

     

       8179
       8179
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8180
       8180
       +
       				return err

     

       8181
       8181
       +
       			}

     

       8182
       8182
       +
       

     

       8183
       8183
       +
       		}

     

       8184
       8184
       +
       	}

     

       7591
       8185
        
       	return nil

     

       7592
       8186
        
       }

     

       7593
       8187
        
       

     
···

       7616
       8210
        
       

     

       7617
       8211
        
       	n := extra

     

       7618
       8212
        
       

     

       7619
       7619
       -
       	nameBuf := make([]byte, 9)

     

       8213
       8213
       +
       	nameBuf := make([]byte, 10)

     

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

     

       7621
       8215
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       7622
       8216
        
       		if err != nil {

     
···

       7726
       8320
        
       				}

     

       7727
       8321
        
       

     

       7728
       8322
        
       			}

     

       8323
       8323
       +
       			// t.Mentions ([]string) (slice)

     

       8324
       8324
       +
       		case "mentions":

     

       8325
       8325
       +
       

     

       8326
       8326
       +
       			maj, extra, err = cr.ReadHeader()

     

       8327
       8327
       +
       			if err != nil {

     

       8328
       8328
       +
       				return err

     

       8329
       8329
       +
       			}

     

       8330
       8330
       +
       

     

       8331
       8331
       +
       			if extra > 8192 {

     

       8332
       8332
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       8333
       8333
       +
       			}

     

       8334
       8334
       +
       

     

       8335
       8335
       +
       			if maj != cbg.MajArray {

     

       8336
       8336
       +
       				return fmt.Errorf("expected cbor array")

     

       8337
       8337
       +
       			}

     

       8338
       8338
       +
       

     

       8339
       8339
       +
       			if extra > 0 {

     

       8340
       8340
       +
       				t.Mentions = make([]string, extra)

     

       8341
       8341
       +
       			}

     

       8342
       8342
       +
       

     

       8343
       8343
       +
       			for i := 0; i < int(extra); i++ {

     

       8344
       8344
       +
       				{

     

       8345
       8345
       +
       					var maj byte

     

       8346
       8346
       +
       					var extra uint64

     

       8347
       8347
       +
       					var err error

     

       8348
       8348
       +
       					_ = maj

     

       8349
       8349
       +
       					_ = extra

     

       8350
       8350
       +
       					_ = err

     

       8351
       8351
       +
       

     

       8352
       8352
       +
       					{

     

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

     

       8354
       8354
       +
       						if err != nil {

     

       8355
       8355
       +
       							return err

     

       8356
       8356
       +
       						}

     

       8357
       8357
       +
       

     

       8358
       8358
       +
       						t.Mentions[i] = string(sval)

     

       8359
       8359
       +
       					}

     

       8360
       8360
       +
       

     

       8361
       8361
       +
       				}

     

       8362
       8362
       +
       			}

     

       7729
       8363
        
       			// t.CreatedAt (string) (string)

     

       7730
       8364
        
       		case "createdAt":

     

       7731
       8365
        
       

     
···

       7737
       8371
        
       

     

       7738
       8372
        
       				t.CreatedAt = string(sval)

     

       7739
       8373
        
       			}

     

       8374
       8374
       +
       			// t.References ([]string) (slice)

     

       8375
       8375
       +
       		case "references":

     

       8376
       8376
       +
       

     

       8377
       8377
       +
       			maj, extra, err = cr.ReadHeader()

     

       8378
       8378
       +
       			if err != nil {

     

       8379
       8379
       +
       				return err

     

       8380
       8380
       +
       			}

     

       8381
       8381
       +
       

     

       8382
       8382
       +
       			if extra > 8192 {

     

       8383
       8383
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       8384
       8384
       +
       			}

     

       8385
       8385
       +
       

     

       8386
       8386
       +
       			if maj != cbg.MajArray {

     

       8387
       8387
       +
       				return fmt.Errorf("expected cbor array")

     

       8388
       8388
       +
       			}

     

       8389
       8389
       +
       

     

       8390
       8390
       +
       			if extra > 0 {

     

       8391
       8391
       +
       				t.References = make([]string, extra)

     

       8392
       8392
       +
       			}

     

       8393
       8393
       +
       

     

       8394
       8394
       +
       			for i := 0; i < int(extra); i++ {

     

       8395
       8395
       +
       				{

     

       8396
       8396
       +
       					var maj byte

     

       8397
       8397
       +
       					var extra uint64

     

       8398
       8398
       +
       					var err error

     

       8399
       8399
       +
       					_ = maj

     

       8400
       8400
       +
       					_ = extra

     

       8401
       8401
       +
       					_ = err

     

       8402
       8402
       +
       

     

       8403
       8403
       +
       					{

     

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

     

       8405
       8405
       +
       						if err != nil {

     

       8406
       8406
       +
       							return err

     

       8407
       8407
       +
       						}

     

       8408
       8408
       +
       

     

       8409
       8409
       +
       						t.References[i] = string(sval)

     

       8410
       8410
       +
       					}

     

       8411
       8411
       +
       

     

       8412
       8412
       +
       				}

     

       8413
       8413
       +
       			}

     

       7740
       8414
        
       

     

       7741
       8415
        
       		default:

     

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

     
···

       7755
       8429
        
       	}

     

       7756
       8430
        
       

     

       7757
       8431
        
       	cw := cbg.NewCborWriter(w)

     

       8432
       8432
       +
       	fieldCount := 6

     

       7758
       8433
        
       

     

       7759
       7759
       -
       	if _, err := cw.Write([]byte{164}); err != nil {

     

       8434
       8434
       +
       	if t.Mentions == nil {

     

       8435
       8435
       +
       		fieldCount--

     

       8436
       8436
       +
       	}

     

       8437
       8437
       +
       

     

       8438
       8438
       +
       	if t.References == nil {

     

       8439
       8439
       +
       		fieldCount--

     

       8440
       8440
       +
       	}

     

       8441
       8441
       +
       

     

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

     

       7760
       8443
        
       		return err

     

       7761
       8444
        
       	}

     

       7762
       8445
        
       

     
···

       7825
       8508
        
       		return err

     

       7826
       8509
        
       	}

     

       7827
       8510
        
       

     

       8511
       8511
       +
       	// t.Mentions ([]string) (slice)

     

       8512
       8512
       +
       	if t.Mentions != nil {

     

       8513
       8513
       +
       

     

       8514
       8514
       +
       		if len("mentions") > 1000000 {

     

       8515
       8515
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       8516
       8516
       +
       		}

     

       8517
       8517
       +
       

     

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

     

       8519
       8519
       +
       			return err

     

       8520
       8520
       +
       		}

     

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

     

       8522
       8522
       +
       			return err

     

       8523
       8523
       +
       		}

     

       8524
       8524
       +
       

     

       8525
       8525
       +
       		if len(t.Mentions) > 8192 {

     

       8526
       8526
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       8527
       8527
       +
       		}

     

       8528
       8528
       +
       

     

       8529
       8529
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       8530
       8530
       +
       			return err

     

       8531
       8531
       +
       		}

     

       8532
       8532
       +
       		for _, v := range t.Mentions {

     

       8533
       8533
       +
       			if len(v) > 1000000 {

     

       8534
       8534
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8535
       8535
       +
       			}

     

       8536
       8536
       +
       

     

       8537
       8537
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8538
       8538
       +
       				return err

     

       8539
       8539
       +
       			}

     

       8540
       8540
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8541
       8541
       +
       				return err

     

       8542
       8542
       +
       			}

     

       8543
       8543
       +
       

     

       8544
       8544
       +
       		}

     

       8545
       8545
       +
       	}

     

       8546
       8546
       +
       

     

       7828
       8547
        
       	// t.CreatedAt (string) (string)

     

       7829
       8548
        
       	if len("createdAt") > 1000000 {

     

       7830
       8549
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       7848
       8567
        
       		return err

     

       7849
       8568
        
       	}

     

       8569
       8569
       +
       

     

       8570
       8570
       +
       	// t.References ([]string) (slice)

     

       8571
       8571
       +
       	if t.References != nil {

     

       8572
       8572
       +
       

     

       8573
       8573
       +
       		if len("references") > 1000000 {

     

       8574
       8574
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       8575
       8575
       +
       		}

     

       8576
       8576
       +
       

     

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

     

       8578
       8578
       +
       			return err

     

       8579
       8579
       +
       		}

     

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

     

       8581
       8581
       +
       			return err

     

       8582
       8582
       +
       		}

     

       8583
       8583
       +
       

     

       8584
       8584
       +
       		if len(t.References) > 8192 {

     

       8585
       8585
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       8586
       8586
       +
       		}

     

       8587
       8587
       +
       

     

       8588
       8588
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       8589
       8589
       +
       			return err

     

       8590
       8590
       +
       		}

     

       8591
       8591
       +
       		for _, v := range t.References {

     

       8592
       8592
       +
       			if len(v) > 1000000 {

     

       8593
       8593
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8594
       8594
       +
       			}

     

       8595
       8595
       +
       

     

       8596
       8596
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8597
       8597
       +
       				return err

     

       8598
       8598
       +
       			}

     

       8599
       8599
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8600
       8600
       +
       				return err

     

       8601
       8601
       +
       			}

     

       8602
       8602
       +
       

     

       8603
       8603
       +
       		}

     

       8604
       8604
       +
       	}

     

       7850
       8605
        
       	return nil

     

       7851
       8606
        
       }

     

       7852
       8607
        
       

     
···

       7875
       8630
        
       

     

       7876
       8631
        
       	n := extra

     

       7877
       8632
        
       

     

       7878
       7878
       -
       	nameBuf := make([]byte, 9)

     

       8633
       8633
       +
       	nameBuf := make([]byte, 10)

     

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

     

       7880
       8635
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       7881
       8636
        
       		if err != nil {

     
···

       7924
       8679
        
       

     

       7925
       8680
        
       				t.LexiconTypeID = string(sval)

     

       7926
       8681
        
       			}

     

       8682
       8682
       +
       			// t.Mentions ([]string) (slice)

     

       8683
       8683
       +
       		case "mentions":

     

       8684
       8684
       +
       

     

       8685
       8685
       +
       			maj, extra, err = cr.ReadHeader()

     

       8686
       8686
       +
       			if err != nil {

     

       8687
       8687
       +
       				return err

     

       8688
       8688
       +
       			}

     

       8689
       8689
       +
       

     

       8690
       8690
       +
       			if extra > 8192 {

     

       8691
       8691
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       8692
       8692
       +
       			}

     

       8693
       8693
       +
       

     

       8694
       8694
       +
       			if maj != cbg.MajArray {

     

       8695
       8695
       +
       				return fmt.Errorf("expected cbor array")

     

       8696
       8696
       +
       			}

     

       8697
       8697
       +
       

     

       8698
       8698
       +
       			if extra > 0 {

     

       8699
       8699
       +
       				t.Mentions = make([]string, extra)

     

       8700
       8700
       +
       			}

     

       8701
       8701
       +
       

     

       8702
       8702
       +
       			for i := 0; i < int(extra); i++ {

     

       8703
       8703
       +
       				{

     

       8704
       8704
       +
       					var maj byte

     

       8705
       8705
       +
       					var extra uint64

     

       8706
       8706
       +
       					var err error

     

       8707
       8707
       +
       					_ = maj

     

       8708
       8708
       +
       					_ = extra

     

       8709
       8709
       +
       					_ = err

     

       8710
       8710
       +
       

     

       8711
       8711
       +
       					{

     

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

     

       8713
       8713
       +
       						if err != nil {

     

       8714
       8714
       +
       							return err

     

       8715
       8715
       +
       						}

     

       8716
       8716
       +
       

     

       8717
       8717
       +
       						t.Mentions[i] = string(sval)

     

       8718
       8718
       +
       					}

     

       8719
       8719
       +
       

     

       8720
       8720
       +
       				}

     

       8721
       8721
       +
       			}

     

       7927
       8722
        
       			// t.CreatedAt (string) (string)

     

       7928
       8723
        
       		case "createdAt":

     

       7929
       8724
        
       

     
···

       7934
       8729
        
       				}

     

       7935
       8730
        
       

     

       7936
       8731
        
       				t.CreatedAt = string(sval)

     

       8732
       8732
       +
       			}

     

       8733
       8733
       +
       			// t.References ([]string) (slice)

     

       8734
       8734
       +
       		case "references":

     

       8735
       8735
       +
       

     

       8736
       8736
       +
       			maj, extra, err = cr.ReadHeader()

     

       8737
       8737
       +
       			if err != nil {

     

       8738
       8738
       +
       				return err

     

       8739
       8739
       +
       			}

     

       8740
       8740
       +
       

     

       8741
       8741
       +
       			if extra > 8192 {

     

       8742
       8742
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       8743
       8743
       +
       			}

     

       8744
       8744
       +
       

     

       8745
       8745
       +
       			if maj != cbg.MajArray {

     

       8746
       8746
       +
       				return fmt.Errorf("expected cbor array")

     

       8747
       8747
       +
       			}

     

       8748
       8748
       +
       

     

       8749
       8749
       +
       			if extra > 0 {

     

       8750
       8750
       +
       				t.References = make([]string, extra)

     

       8751
       8751
       +
       			}

     

       8752
       8752
       +
       

     

       8753
       8753
       +
       			for i := 0; i < int(extra); i++ {

     

       8754
       8754
       +
       				{

     

       8755
       8755
       +
       					var maj byte

     

       8756
       8756
       +
       					var extra uint64

     

       8757
       8757
       +
       					var err error

     

       8758
       8758
       +
       					_ = maj

     

       8759
       8759
       +
       					_ = extra

     

       8760
       8760
       +
       					_ = err

     

       8761
       8761
       +
       

     

       8762
       8762
       +
       					{

     

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

     

       8764
       8764
       +
       						if err != nil {

     

       8765
       8765
       +
       							return err

     

       8766
       8766
       +
       						}

     

       8767
       8767
       +
       

     

       8768
       8768
       +
       						t.References[i] = string(sval)

     

       8769
       8769
       +
       					}

     

       8770
       8770
       +
       

     

       8771
       8771
       +
       				}

     

       7937
       8772
        
       			}

     

       7938
       8773
        
       

     

       7939
       8774
        
       		default:

+7 -5

api/tangled/issuecomment.go

···

       17
       17
        
       } //

     

       18
       18
        
       // RECORDTYPE: RepoIssueComment

     

       19
       19
        
       type RepoIssueComment struct {

     

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

     

       21
       21
       -
       	Body          string  `json:"body" cborgen:"body"`

     

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

     

       23
       23
       -
       	Issue         string  `json:"issue" cborgen:"issue"`

     

       24
       24
       -
       	ReplyTo       *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"`

     

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

     

       21
       21
       +
       	Body          string   `json:"body" cborgen:"body"`

     

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

     

       23
       23
       +
       	Issue         string   `json:"issue" cborgen:"issue"`

     

       24
       24
       +
       	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

     

       25
       25
       +
       	References    []string `json:"references,omitempty" cborgen:"references,omitempty"`

     

       26
       26
       +
       	ReplyTo       *string  `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"`

     

       25
       27
        
       }

+6 -4

api/tangled/pullcomment.go

···

       17
       17
        
       } //

     

       18
       18
        
       // RECORDTYPE: RepoPullComment

     

       19
       19
        
       type RepoPullComment struct {

     

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

     

       21
       21
       -
       	Body          string `json:"body" cborgen:"body"`

     

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

     

       23
       23
       -
       	Pull          string `json:"pull" cborgen:"pull"`

     

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

     

       21
       21
       +
       	Body          string   `json:"body" cborgen:"body"`

     

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

     

       23
       23
       +
       	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

     

       24
       24
       +
       	Pull          string   `json:"pull" cborgen:"pull"`

     

       25
       25
       +
       	References    []string `json:"references,omitempty" cborgen:"references,omitempty"`

     

       24
       26
        
       }

+13 -1

api/tangled/repoblob.go

···

       30
       30
        
       // RepoBlob_Output is the output of a sh.tangled.repo.blob call.

     

       31
       31
        
       type RepoBlob_Output struct {

     

       32
       32
        
       	// content: File content (base64 encoded for binary files)

     

       33
       33
       -
       	Content string `json:"content" cborgen:"content"`

     

       33
       33
       +
       	Content *string `json:"content,omitempty" cborgen:"content,omitempty"`

     

       34
       34
        
       	// encoding: Content encoding

     

       35
       35
        
       	Encoding *string `json:"encoding,omitempty" cborgen:"encoding,omitempty"`

     

       36
       36
        
       	// isBinary: Whether the file is binary

     
···

       44
       44
        
       	Ref string `json:"ref" cborgen:"ref"`

     

       45
       45
        
       	// size: File size in bytes

     

       46
       46
        
       	Size *int64 `json:"size,omitempty" cborgen:"size,omitempty"`

     

       47
       47
       +
       	// submodule: Submodule information if path is a submodule

     

       48
       48
       +
       	Submodule *RepoBlob_Submodule `json:"submodule,omitempty" cborgen:"submodule,omitempty"`

     

       47
       49
        
       }

     

       48
       50
        
       

     

       49
       51
        
       // RepoBlob_Signature is a "signature" in the sh.tangled.repo.blob schema.

     
···

       54
       56
        
       	Name string `json:"name" cborgen:"name"`

     

       55
       57
        
       	// when: Author timestamp

     

       56
       58
        
       	When string `json:"when" cborgen:"when"`

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

       61
       61
       +
       // RepoBlob_Submodule is a "submodule" in the sh.tangled.repo.blob schema.

     

       62
       62
       +
       type RepoBlob_Submodule struct {

     

       63
       63
       +
       	// branch: Branch to track in the submodule

     

       64
       64
       +
       	Branch *string `json:"branch,omitempty" cborgen:"branch,omitempty"`

     

       65
       65
       +
       	// name: Submodule name

     

       66
       66
       +
       	Name string `json:"name" cborgen:"name"`

     

       67
       67
       +
       	// url: Submodule repository URL

     

       68
       68
       +
       	Url string `json:"url" cborgen:"url"`

     

       57
       69
        
       }

     

       58
       70
        
       

     

       59
       71
        
       // RepoBlob calls the XRPC method "sh.tangled.repo.blob".

+7 -5

api/tangled/repoissue.go

···

       17
       17
        
       } //

     

       18
       18
        
       // RECORDTYPE: RepoIssue

     

       19
       19
        
       type RepoIssue struct {

     

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

     

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

     

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

     

       23
       23
       -
       	Repo          string  `json:"repo" cborgen:"repo"`

     

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

     

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

     

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

     

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

     

       23
       23
       +
       	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

     

       24
       24
       +
       	References    []string `json:"references,omitempty" cborgen:"references,omitempty"`

     

       25
       25
       +
       	Repo          string   `json:"repo" cborgen:"repo"`

     

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

     

       25
       27
        
       }

api/tangled/repopull.go

···

       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
       +
       	Mentions      []string         `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

     

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

     

       25
       25
       +
       	References    []string         `json:"references,omitempty" cborgen:"references,omitempty"`

     

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

     

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

     

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

-4

api/tangled/repotree.go

···

       47
       47
        
       

     

       48
       48
        
       // RepoTree_TreeEntry is a "treeEntry" in the sh.tangled.repo.tree schema.

     

       49
       49
        
       type RepoTree_TreeEntry struct {

     

       50
       50
       -
       	// is_file: Whether this entry is a file

     

       51
       51
       -
       	Is_file bool `json:"is_file" cborgen:"is_file"`

     

       52
       52
       -
       	// is_subtree: Whether this entry is a directory/subtree

     

       53
       53
       -
       	Is_subtree  bool                 `json:"is_subtree" cborgen:"is_subtree"`

     

       54
       50
        
       	Last_commit *RepoTree_LastCommit `json:"last_commit,omitempty" cborgen:"last_commit,omitempty"`

     

       55
       51
        
       	// mode: File mode

     

       56
       52
        
       	Mode string `json:"mode" cborgen:"mode"`

api/tangled/tangledrepo.go

···

       30
       30
        
       	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`

     

       31
       31
        
       	// spindle: CI runner to send jobs to and receive results from

     

       32
       32
        
       	Spindle *string `json:"spindle,omitempty" cborgen:"spindle,omitempty"`

     

       33
       33
       +
       	// topics: Topics related to the repo

     

       34
       34
       +
       	Topics []string `json:"topics,omitempty" cborgen:"topics,omitempty"`

     

       35
       35
       +
       	// website: Any URI related to the repo

     

       36
       36
       +
       	Website *string `json:"website,omitempty" cborgen:"website,omitempty"`

     

       33
       37
        
       }

+6 -45

appview/commitverify/verify.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"log"

     

       5
       5
        
       

     

       6
       6
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       7
       6
        
       	"tangled.org/core/appview/db"

     

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

     

       9
       8
        
       	"tangled.org/core/crypto"

     
···

       35
       34
        
       	return ""

     

       36
       35
        
       }

     

       37
       36
        
       

     

       38
       38
       -
       func GetVerifiedObjectCommits(e db.Execer, emailToDid map[string]string, commits []*object.Commit) (VerifiedCommits, error) {

     

       39
       39
       -
       	ndCommits := []types.NiceDiff{}

     

       40
       40
       -
       	for _, commit := range commits {

     

       41
       41
       -
       		ndCommits = append(ndCommits, ObjectCommitToNiceDiff(commit))

     

       42
       42
       -
       	}

     

       43
       43
       -
       	return GetVerifiedCommits(e, emailToDid, ndCommits)

     

       44
       44
       -
       }

     

       45
       45
       -
       

     

       46
       46
       -
       func GetVerifiedCommits(e db.Execer, emailToDid map[string]string, ndCommits []types.NiceDiff) (VerifiedCommits, error) {

     

       37
       37
       +
       func GetVerifiedCommits(e db.Execer, emailToDid map[string]string, ndCommits []types.Commit) (VerifiedCommits, error) {

     

       47
       38
        
       	vcs := VerifiedCommits{}

     

       48
       39
        
       

     

       49
       40
        
       	didPubkeyCache := make(map[string][]models.PublicKey)

     

       50
       41
        
       

     

       51
       42
        
       	for _, commit := range ndCommits {

     

       52
       52
       -
       		c := commit.Commit

     

       53
       53
       -
       

     

       54
       54
       -
       		committerEmail := c.Committer.Email

     

       43
       43
       +
       		committerEmail := commit.Committer.Email

     

       55
       44
        
       		if did, exists := emailToDid[committerEmail]; exists {

     

       56
       45
        
       			// check if we've already fetched public keys for this did

     

       57
       46
        
       			pubKeys, ok := didPubkeyCache[did]

     
···

       67
       56
        
       			}

     

       68
       57
        
       

     

       69
       58
        
       			// try to verify with any associated pubkeys

     

       59
       59
       +
       			payload := commit.Payload()

     

       60
       60
       +
       			signature := commit.PGPSignature

     

       70
       61
        
       			for _, pk := range pubKeys {

     

       71
       71
       -
       				if _, ok := crypto.VerifyCommitSignature(pk.Key, commit); ok {

     

       62
       62
       +
       				if _, ok := crypto.VerifySignature([]byte(pk.Key), []byte(signature), []byte(payload)); ok {

     

       72
       63
        
       

     

       73
       64
        
       					fp, err := crypto.SSHFingerprint(pk.Key)

     

       74
       65
        
       					if err != nil {

     

       75
       66
        
       						log.Println("error computing ssh fingerprint:", err)

     

       76
       67
        
       					}

     

       77
       68
        
       

     

       78
       78
       -
       					vc := verifiedCommit{fingerprint: fp, hash: c.This}

     

       69
       69
       +
       					vc := verifiedCommit{fingerprint: fp, hash: commit.This}

     

       79
       70
        
       					vcs[vc] = struct{}{}

     

       80
       71
        
       					break

     

       81
       72
        
       				}

     
···

       86
       77
        
       

     

       87
       78
        
       	return vcs, nil

     

       88
       79
        
       }

     

       89
       89
       -
       

     

       90
       90
       -
       // ObjectCommitToNiceDiff is a compatibility function to convert a

     

       91
       91
       -
       // commit object into a NiceDiff structure.

     

       92
       92
       -
       func ObjectCommitToNiceDiff(c *object.Commit) types.NiceDiff {

     

       93
       93
       -
       	var niceDiff types.NiceDiff

     

       94
       94
       -
       

     

       95
       95
       -
       	// set commit information

     

       96
       96
       -
       	niceDiff.Commit.Message = c.Message

     

       97
       97
       -
       	niceDiff.Commit.Author = c.Author

     

       98
       98
       -
       	niceDiff.Commit.This = c.Hash.String()

     

       99
       99
       -
       	niceDiff.Commit.Committer = c.Committer

     

       100
       100
       -
       	niceDiff.Commit.Tree = c.TreeHash.String()

     

       101
       101
       -
       	niceDiff.Commit.PGPSignature = c.PGPSignature

     

       102
       102
       -
       

     

       103
       103
       -
       	changeId, ok := c.ExtraHeaders["change-id"]

     

       104
       104
       -
       	if ok {

     

       105
       105
       -
       		niceDiff.Commit.ChangedId = string(changeId)

     

       106
       106
       -
       	}

     

       107
       107
       -
       

     

       108
       108
       -
       	// set parent hash if available

     

       109
       109
       -
       	if len(c.ParentHashes) > 0 {

     

       110
       110
       -
       		niceDiff.Commit.Parent = c.ParentHashes[0].String()

     

       111
       111
       -
       	}

     

       112
       112
       -
       

     

       113
       113
       -
       	// XXX: Stats and Diff fields are typically populated

     

       114
       114
       -
       	// after fetching the actual diff information, which isn't

     

       115
       115
       -
       	// directly available in the commit object itself.

     

       116
       116
       -
       

     

       117
       117
       -
       	return niceDiff

     

       118
       118
       -
       }

+15 -2

appview/config/config.go

···

       13
       13
        
       	CookieSecret            string `env:"COOKIE_SECRET, default=00000000000000000000000000000000"`

     

       14
       14
        
       	DbPath                  string `env:"DB_PATH, default=appview.db"`

     

       15
       15
        
       	ListenAddr              string `env:"LISTEN_ADDR, default=0.0.0.0:3000"`

     

       16
       16
       -
       	AppviewHost             string `env:"APPVIEW_HOST, default=https://tangled.sh"`

     

       16
       16
       +
       	AppviewHost             string `env:"APPVIEW_HOST, default=https://tangled.org"`

     

       17
       17
       +
       	AppviewName             string `env:"APPVIEW_Name, default=Tangled"`

     

       17
       18
        
       	Dev                     bool   `env:"DEV, default=false"`

     

       18
       19
        
       	DisallowedNicknamesFile string `env:"DISALLOWED_NICKNAMES_FILE"`

     

       19
       20
        
       

     
···

       25
       26
        
       }

     

       26
       27
        
       

     

       27
       28
        
       type OAuthConfig struct {

     

       28
       28
       -
       	Jwks string `env:"JWKS"`

     

       29
       29
       +
       	ClientSecret string `env:"CLIENT_SECRET"`

     

       30
       30
       +
       	ClientKid    string `env:"CLIENT_KID"`

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       type PlcConfig struct {

     

       34
       34
       +
       	PLCURL string `env:"URL, default=https://plc.directory"`

     

       29
       35
        
       }

     

       30
       36
        
       

     

       31
       37
        
       type JetstreamConfig struct {

     
···

       78
       84
        
       	TurnstileSecretKey string `env:"TURNSTILE_SECRET_KEY"`

     

       79
       85
        
       }

     

       80
       86
        
       

     

       87
       87
       +
       type LabelConfig struct {

     

       88
       88
       +
       	DefaultLabelDefs []string `env:"DEFAULTS, default=at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/wontfix,at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue,at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/duplicate,at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/documentation,at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/assignee"` // delimiter=,

     

       89
       89
       +
       	GoodFirstIssue   string   `env:"GFI, default=at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue"`

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       81
       92
        
       func (cfg RedisConfig) ToURL() string {

     

       82
       93
        
       	u := &url.URL{

     

       83
       94
        
       		Scheme: "redis",

     
···

       103
       114
        
       	Avatar        AvatarConfig    `env:",prefix=TANGLED_AVATAR_"`

     

       104
       115
        
       	OAuth         OAuthConfig     `env:",prefix=TANGLED_OAUTH_"`

     

       105
       116
        
       	Redis         RedisConfig     `env:",prefix=TANGLED_REDIS_"`

     

       117
       117
       +
       	Plc           PlcConfig       `env:",prefix=TANGLED_PLC_"`

     

       106
       118
        
       	Pds           PdsConfig       `env:",prefix=TANGLED_PDS_"`

     

       107
       119
        
       	Cloudflare    Cloudflare      `env:",prefix=TANGLED_CLOUDFLARE_"`

     

       120
       120
       +
       	Label         LabelConfig     `env:",prefix=TANGLED_LABEL_"`

     

       108
       121
        
       }

     

       109
       122
        
       

     

       110
       123
        
       func LoadConfig(ctx context.Context) (*Config, error) {

+3 -2

appview/db/artifact.go

···

       8
       8
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       9
        
       	"github.com/ipfs/go-cid"

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

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

     

       11
       12
        
       )

     

       12
       13
        
       

     

       13
       14
        
       func AddArtifact(e Execer, artifact models.Artifact) error {

     
···

       37
       38
        
       	return err

     

       38
       39
        
       }

     

       39
       40
        
       

     

       40
       40
       -
       func GetArtifact(e Execer, filters ...filter) ([]models.Artifact, error) {

     

       41
       41
       +
       func GetArtifact(e Execer, filters ...orm.Filter) ([]models.Artifact, error) {

     

       41
       42
        
       	var artifacts []models.Artifact

     

       42
       43
        
       

     

       43
       44
        
       	var conditions []string

     
···

       109
       110
        
       	return artifacts, nil

     

       110
       111
        
       }

     

       111
       112
        
       

     

       112
       112
       -
       func DeleteArtifact(e Execer, filters ...filter) error {

     

       113
       113
       +
       func DeleteArtifact(e Execer, filters ...orm.Filter) error {

     

       113
       114
        
       	var conditions []string

     

       114
       115
        
       	var args []any

     

       115
       116
        
       	for _, filter := range filters {

+4 -3

appview/db/collaborators.go

···

       6
       6
        
       	"time"

     

       7
       7
        
       

     

       8
       8
        
       	"tangled.org/core/appview/models"

     

       9
       9
       +
       	"tangled.org/core/orm"

     

       9
       10
        
       )

     

       10
       11
        
       

     

       11
       12
        
       func AddCollaborator(e Execer, c models.Collaborator) error {

     
···

       16
       17
        
       	return err

     

       17
       18
        
       }

     

       18
       19
        
       

     

       19
       19
       -
       func DeleteCollaborator(e Execer, filters ...filter) error {

     

       20
       20
       +
       func DeleteCollaborator(e Execer, filters ...orm.Filter) error {

     

       20
       21
        
       	var conditions []string

     

       21
       22
        
       	var args []any

     

       22
       23
        
       	for _, filter := range filters {

     
···

       58
       59
        
       		return nil, nil

     

       59
       60
        
       	}

     

       60
       61
        
       

     

       61
       61
       -
       	return GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       62
       62
       +
       	return GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       62
       63
        
       }

     

       63
       64
        
       

     

       64
       64
       -
       func GetCollaborators(e Execer, filters ...filter) ([]models.Collaborator, error) {

     

       65
       65
       +
       func GetCollaborators(e Execer, filters ...orm.Filter) ([]models.Collaborator, error) {

     

       65
       66
        
       	var collaborators []models.Collaborator

     

       66
       67
        
       	var conditions []string

     

       67
       68
        
       	var args []any

+85 -130

appview/db/db.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"database/sql"

     

       6
       6
       -
       	"fmt"

     

       7
       6
        
       	"log/slog"

     

       8
       8
       -
       	"reflect"

     

       9
       7
        
       	"strings"

     

       10
       8
        
       

     

       11
       9
        
       	_ "github.com/mattn/go-sqlite3"

     

       12
       10
        
       	"tangled.org/core/log"

     

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

     

       13
       12
        
       )

     

       14
       13
        
       

     

       15
       14
        
       type DB struct {

     
···

       561
       560
        
       			email_notifications integer not null default 0

     

       562
       561
        
       		);

     

       563
       562
        
       

     

       563
       563
       +
       		create table if not exists reference_links (

     

       564
       564
       +
       			id integer primary key autoincrement,

     

       565
       565
       +
       			from_at text not null,

     

       566
       566
       +
       			to_at text not null,

     

       567
       567
       +
       			unique (from_at, to_at)

     

       568
       568
       +
       		);

     

       569
       569
       +
       

     

       564
       570
        
       		create table if not exists migrations (

     

       565
       571
        
       			id integer primary key autoincrement,

     

       566
       572
        
       			name text unique

     
···

       569
       575
        
       		-- indexes for better performance

     

       570
       576
        
       		create index if not exists idx_notifications_recipient_created on notifications(recipient_did, created desc);

     

       571
       577
        
       		create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read);

     

       572
       572
       -
       		create index if not exists idx_stars_created on stars(created);

     

       573
       573
       -
       		create index if not exists idx_stars_repo_at_created on stars(repo_at, created);

     

       578
       578
       +
       		create index if not exists idx_references_from_at on reference_links(from_at);

     

       579
       579
       +
       		create index if not exists idx_references_to_at on reference_links(to_at);

     

       574
       580
        
       	`)

     

       575
       581
        
       	if err != nil {

     

       576
       582
        
       		return nil, err

     

       577
       583
        
       	}

     

       578
       584
        
       

     

       579
       585
        
       	// run migrations

     

       580
       580
       -
       	runMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       586
       586
       +
       	orm.RunMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       581
       587
        
       		tx.Exec(`

     

       582
       588
        
       			alter table repos add column description text check (length(description) <= 200);

     

       583
       589
        
       		`)

     

       584
       590
        
       		return nil

     

       585
       591
        
       	})

     

       586
       592
        
       

     

       587
       587
       -
       	runMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       593
       593
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       588
       594
        
       		// add unconstrained column

     

       589
       595
        
       		_, err := tx.Exec(`

     

       590
       596
        
       			alter table public_keys

     
···

       607
       613
        
       		return nil

     

       608
       614
        
       	})

     

       609
       615
        
       

     

       610
       610
       -
       	runMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       616
       616
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       611
       617
        
       		_, err := tx.Exec(`

     

       612
       618
        
       			alter table comments drop column comment_at;

     

       613
       619
        
       			alter table comments add column rkey text;

     
···

       615
       621
        
       		return err

     

       616
       622
        
       	})

     

       617
       623
        
       

     

       618
       618
       -
       	runMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       624
       624
       +
       	orm.RunMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       619
       625
        
       		_, err := tx.Exec(`

     

       620
       626
        
       			alter table comments add column deleted text; -- timestamp

     

       621
       627
        
       			alter table comments add column edited text; -- timestamp

     
···

       623
       629
        
       		return err

     

       624
       630
        
       	})

     

       625
       631
        
       

     

       626
       626
       -
       	runMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       632
       632
       +
       	orm.RunMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       627
       633
        
       		_, err := tx.Exec(`

     

       628
       634
        
       			alter table pulls add column source_branch text;

     

       629
       635
        
       			alter table pulls add column source_repo_at text;

     
···

       632
       638
        
       		return err

     

       633
       639
        
       	})

     

       634
       640
        
       

     

       635
       635
       -
       	runMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       641
       641
       +
       	orm.RunMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       636
       642
        
       		_, err := tx.Exec(`

     

       637
       643
        
       			alter table repos add column source text;

     

       638
       644
        
       		`)

     
···

       644
       650
        
       	//

     

       645
       651
        
       	// [0]: https://sqlite.org/pragma.html#pragma_foreign_keys

     

       646
       652
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       647
       647
       -
       	runMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       653
       653
       +
       	orm.RunMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       648
       654
        
       		_, err := tx.Exec(`

     

       649
       655
        
       			create table pulls_new (

     

       650
       656
        
       				-- identifiers

     
···

       701
       707
        
       	})

     

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

     

       703
       709
        
       

     

       704
       704
       -
       	runMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       710
       710
       +
       	orm.RunMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       705
       711
        
       		tx.Exec(`

     

       706
       712
        
       			alter table repos add column spindle text;

     

       707
       713
        
       		`)

     
···

       711
       717
        
       	// drop all knot secrets, add unique constraint to knots

     

       712
       718
        
       	//

     

       713
       719
        
       	// knots will henceforth use service auth for signed requests

     

       714
       714
       -
       	runMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       720
       720
       +
       	orm.RunMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       715
       721
        
       		_, err := tx.Exec(`

     

       716
       722
        
       			create table registrations_new (

     

       717
       723
        
       				id integer primary key autoincrement,

     
···

       734
       740
        
       	})

     

       735
       741
        
       

     

       736
       742
        
       	// recreate and add rkey + created columns with default constraint

     

       737
       737
       -
       	runMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       743
       743
       +
       	orm.RunMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       738
       744
        
       		// create new table

     

       739
       745
        
       		// - repo_at instead of repo integer

     

       740
       746
        
       		// - rkey field

     
···

       788
       794
        
       		return err

     

       789
       795
        
       	})

     

       790
       796
        
       

     

       791
       791
       -
       	runMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       797
       797
       +
       	orm.RunMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       792
       798
        
       		_, err := tx.Exec(`

     

       793
       799
        
       			alter table issues add column rkey text not null default '';

     

       794
       800
        
       

     
···

       800
       806
        
       	})

     

       801
       807
        
       

     

       802
       808
        
       	// repurpose the read-only column to "needs-upgrade"

     

       803
       803
       -
       	runMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       809
       809
       +
       	orm.RunMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       804
       810
        
       		_, err := tx.Exec(`

     

       805
       811
        
       			alter table registrations rename column read_only to needs_upgrade;

     

       806
       812
        
       		`)

     
···

       808
       814
        
       	})

     

       809
       815
        
       

     

       810
       816
        
       	// require all knots to upgrade after the release of total xrpc

     

       811
       811
       -
       	runMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       817
       817
       +
       	orm.RunMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       812
       818
        
       		_, err := tx.Exec(`

     

       813
       819
        
       			update registrations set needs_upgrade = 1;

     

       814
       820
        
       		`)

     
···

       816
       822
        
       	})

     

       817
       823
        
       

     

       818
       824
        
       	// require all knots to upgrade after the release of total xrpc

     

       819
       819
       -
       	runMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       825
       825
       +
       	orm.RunMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       820
       826
        
       		_, err := tx.Exec(`

     

       821
       827
        
       			alter table spindles add column needs_upgrade integer not null default 0;

     

       822
       828
        
       		`)

     
···

       834
       840
        
       	//

     

       835
       841
        
       	// disable foreign-keys for the next migration

     

       836
       842
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       837
       837
       -
       	runMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       843
       843
       +
       	orm.RunMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       838
       844
        
       		_, err := tx.Exec(`

     

       839
       845
        
       			create table if not exists issues_new (

     

       840
       846
        
       				-- identifiers

     
···

       904
       910
        
       	// - new columns

     

       905
       911
        
       	//   * column "reply_to" which can be any other comment

     

       906
       912
        
       	//   * column "at-uri" which is a generated column

     

       907
       907
       -
       	runMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       913
       913
       +
       	orm.RunMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       908
       914
        
       		_, err := tx.Exec(`

     

       909
       915
        
       			create table if not exists issue_comments (

     

       910
       916
        
       				-- identifiers

     
···

       964
       970
        
       	//

     

       965
       971
        
       	// disable foreign-keys for the next migration

     

       966
       972
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       967
       967
       -
       	runMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       973
       973
       +
       	orm.RunMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       968
       974
        
       		_, err := tx.Exec(`

     

       969
       975
        
       		create table if not exists pulls_new (

     

       970
       976
        
       			-- identifiers

     
···

       1045
       1051
        
       	//

     

       1046
       1052
        
       	// disable foreign-keys for the next migration

     

       1047
       1053
        
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       1048
       1048
       -
       	runMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       1054
       1054
       +
       	orm.RunMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       1049
       1055
        
       		_, err := tx.Exec(`

     

       1050
       1056
        
       		create table if not exists pull_submissions_new (

     

       1051
       1057
        
       			-- identifiers

     
···

       1099
       1105
        
       

     

       1100
       1106
        
       	// knots may report the combined patch for a comparison, we can store that on the appview side

     

       1101
       1107
        
       	// (but not on the pds record), because calculating the combined patch requires a git index

     

       1102
       1102
       -
       	runMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       1108
       1108
       +
       	orm.RunMigration(conn, logger, "add-combined-column-submissions", func(tx *sql.Tx) error {

     

       1103
       1109
        
       		_, err := tx.Exec(`

     

       1104
       1110
        
       			alter table pull_submissions add column combined text;

     

       1105
       1111
        
       		`)

     

       1106
       1112
        
       		return err

     

       1107
       1113
        
       	})

     

       1108
       1114
        
       

     

       1109
       1109
       -
       	return &DB{

     

       1110
       1110
       -
       		db,

     

       1111
       1111
       -
       		logger,

     

       1112
       1112
       -
       	}, nil

     

       1113
       1113
       -
       }

     

       1115
       1115
       +
       	orm.RunMigration(conn, logger, "add-pronouns-profile", func(tx *sql.Tx) error {

     

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

     

       1117
       1117
       +
       			alter table profile add column pronouns text;

     

       1118
       1118
       +
       		`)

     

       1119
       1119
       +
       		return err

     

       1120
       1120
       +
       	})

     

       1114
       1121
        
       

     

       1115
       1115
       -
       type migrationFn = func(*sql.Tx) error

     

       1116
       1116
       -
       

     

       1117
       1117
       -
       func runMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       1118
       1118
       -
       	logger = logger.With("migration", name)

     

       1119
       1119
       -
       

     

       1120
       1120
       -
       	tx, err := c.BeginTx(context.Background(), nil)

     

       1121
       1121
       -
       	if err != nil {

     

       1122
       1122
       +
       	orm.RunMigration(conn, logger, "add-meta-column-repos", func(tx *sql.Tx) error {

     

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

     

       1124
       1124
       +
       			alter table repos add column website text;

     

       1125
       1125
       +
       			alter table repos add column topics text;

     

       1126
       1126
       +
       		`)

     

       1122
       1127
        
       		return err

     

       1123
       1123
       -
       	}

     

       1124
       1124
       -
       	defer tx.Rollback()

     

       1128
       1128
       +
       	})

     

       1125
       1129
        
       

     

       1126
       1126
       -
       	var exists bool

     

       1127
       1127
       -
       	err = tx.QueryRow("select exists (select 1 from migrations where name = ?)", name).Scan(&exists)

     

       1128
       1128
       -
       	if err != nil {

     

       1130
       1130
       +
       	orm.RunMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {

     

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

     

       1132
       1132
       +
       			alter table notification_preferences add column user_mentioned integer not null default 1;

     

       1133
       1133
       +
       		`)

     

       1129
       1134
        
       		return err

     

       1130
       1130
       -
       	}

     

       1135
       1135
       +
       	})

     

       1136
       1136
       +
       

     

       1137
       1137
       +
       	// remove the foreign key constraints from stars.

     

       1138
       1138
       +
       	orm.RunMigration(conn, logger, "generalize-stars-subject", func(tx *sql.Tx) error {

     

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

     

       1140
       1140
       +
       			create table stars_new (

     

       1141
       1141
       +
       				id integer primary key autoincrement,

     

       1142
       1142
       +
       				did text not null,

     

       1143
       1143
       +
       				rkey text not null,

     

       1144
       1144
       +
       

     

       1145
       1145
       +
       				subject_at text not null,

     

       1131
       1146
        
       

     

       1132
       1132
       -
       	if !exists {

     

       1133
       1133
       -
       		// run migration

     

       1134
       1134
       -
       		err = migrationFn(tx)

     

       1135
       1135
       -
       		if err != nil {

     

       1136
       1136
       -
       			logger.Error("failed to run migration", "err", err)

     

       1137
       1137
       -
       			return err

     

       1138
       1138
       -
       		}

     

       1147
       1147
       +
       				created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       1148
       1148
       +
       				unique(did, rkey),

     

       1149
       1149
       +
       				unique(did, subject_at)

     

       1150
       1150
       +
       			);

     

       1139
       1151
        
       

     

       1140
       1140
       -
       		// mark migration as complete

     

       1141
       1141
       -
       		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       1142
       1142
       -
       		if err != nil {

     

       1143
       1143
       -
       			logger.Error("failed to mark migration as complete", "err", err)

     

       1144
       1144
       -
       			return err

     

       1145
       1145
       -
       		}

     

       1152
       1152
       +
       			insert into stars_new (

     

       1153
       1153
       +
       				id,

     

       1154
       1154
       +
       				did,

     

       1155
       1155
       +
       				rkey,

     

       1156
       1156
       +
       				subject_at,

     

       1157
       1157
       +
       				created

     

       1158
       1158
       +
       			)

     

       1159
       1159
       +
       			select

     

       1160
       1160
       +
       				id,

     

       1161
       1161
       +
       				starred_by_did,

     

       1162
       1162
       +
       				rkey,

     

       1163
       1163
       +
       				repo_at,

     

       1164
       1164
       +
       				created

     

       1165
       1165
       +
       			from stars;

     

       1146
       1166
        
       

     

       1147
       1147
       -
       		// commit the transaction

     

       1148
       1148
       -
       		if err := tx.Commit(); err != nil {

     

       1149
       1149
       -
       			return err

     

       1150
       1150
       -
       		}

     

       1167
       1167
       +
       			drop table stars;

     

       1168
       1168
       +
       			alter table stars_new rename to stars;

     

       1151
       1169
        
       

     

       1152
       1152
       -
       		logger.Info("migration applied successfully")

     

       1153
       1153
       -
       	} else {

     

       1154
       1154
       -
       		logger.Warn("skipped migration, already applied")

     

       1155
       1155
       -
       	}

     

       1170
       1170
       +
       			create index if not exists idx_stars_created on stars(created);

     

       1171
       1171
       +
       			create index if not exists idx_stars_subject_at_created on stars(subject_at, created);

     

       1172
       1172
       +
       		`)

     

       1173
       1173
       +
       		return err

     

       1174
       1174
       +
       	})

     

       1156
       1175
        
       

     

       1157
       1157
       -
       	return nil

     

       1176
       1176
       +
       	return &DB{

     

       1177
       1177
       +
       		db,

     

       1178
       1178
       +
       		logger,

     

       1179
       1179
       +
       	}, nil

     

       1158
       1180
        
       }

     

       1159
       1181
        
       

     

       1160
       1182
        
       func (d *DB) Close() error {

     

       1161
       1183
        
       	return d.DB.Close()

     

       1162
       1184
        
       }

     

       1163
       1163
       -
       

     

       1164
       1164
       -
       type filter struct {

     

       1165
       1165
       -
       	key string

     

       1166
       1166
       -
       	arg any

     

       1167
       1167
       -
       	cmp string

     

       1168
       1168
       -
       }

     

       1169
       1169
       -
       

     

       1170
       1170
       -
       func newFilter(key, cmp string, arg any) filter {

     

       1171
       1171
       -
       	return filter{

     

       1172
       1172
       -
       		key: key,

     

       1173
       1173
       -
       		arg: arg,

     

       1174
       1174
       -
       		cmp: cmp,

     

       1175
       1175
       -
       	}

     

       1176
       1176
       -
       }

     

       1177
       1177
       -
       

     

       1178
       1178
       -
       func FilterEq(key string, arg any) filter      { return newFilter(key, "=", arg) }

     

       1179
       1179
       -
       func FilterNotEq(key string, arg any) filter   { return newFilter(key, "<>", arg) }

     

       1180
       1180
       -
       func FilterGte(key string, arg any) filter     { return newFilter(key, ">=", arg) }

     

       1181
       1181
       -
       func FilterLte(key string, arg any) filter     { return newFilter(key, "<=", arg) }

     

       1182
       1182
       -
       func FilterIs(key string, arg any) filter      { return newFilter(key, "is", arg) }

     

       1183
       1183
       -
       func FilterIsNot(key string, arg any) filter   { return newFilter(key, "is not", arg) }

     

       1184
       1184
       -
       func FilterIn(key string, arg any) filter      { return newFilter(key, "in", arg) }

     

       1185
       1185
       -
       func FilterLike(key string, arg any) filter    { return newFilter(key, "like", arg) }

     

       1186
       1186
       -
       func FilterNotLike(key string, arg any) filter { return newFilter(key, "not like", arg) }

     

       1187
       1187
       -
       func FilterContains(key string, arg any) filter {

     

       1188
       1188
       -
       	return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))

     

       1189
       1189
       -
       }

     

       1190
       1190
       -
       

     

       1191
       1191
       -
       func (f filter) Condition() string {

     

       1192
       1192
       -
       	rv := reflect.ValueOf(f.arg)

     

       1193
       1193
       -
       	kind := rv.Kind()

     

       1194
       1194
       -
       

     

       1195
       1195
       -
       	// if we have `FilterIn(k, [1, 2, 3])`, compile it down to `k in (?, ?, ?)`

     

       1196
       1196
       -
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       1197
       1197
       -
       		if rv.Len() == 0 {

     

       1198
       1198
       -
       			// always false

     

       1199
       1199
       -
       			return "1 = 0"

     

       1200
       1200
       -
       		}

     

       1201
       1201
       -
       

     

       1202
       1202
       -
       		placeholders := make([]string, rv.Len())

     

       1203
       1203
       -
       		for i := range placeholders {

     

       1204
       1204
       -
       			placeholders[i] = "?"

     

       1205
       1205
       -
       		}

     

       1206
       1206
       -
       

     

       1207
       1207
       -
       		return fmt.Sprintf("%s %s (%s)", f.key, f.cmp, strings.Join(placeholders, ", "))

     

       1208
       1208
       -
       	}

     

       1209
       1209
       -
       

     

       1210
       1210
       -
       	return fmt.Sprintf("%s %s ?", f.key, f.cmp)

     

       1211
       1211
       -
       }

     

       1212
       1212
       -
       

     

       1213
       1213
       -
       func (f filter) Arg() []any {

     

       1214
       1214
       -
       	rv := reflect.ValueOf(f.arg)

     

       1215
       1215
       -
       	kind := rv.Kind()

     

       1216
       1216
       -
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       1217
       1217
       -
       		if rv.Len() == 0 {

     

       1218
       1218
       -
       			return nil

     

       1219
       1219
       -
       		}

     

       1220
       1220
       -
       

     

       1221
       1221
       -
       		out := make([]any, rv.Len())

     

       1222
       1222
       -
       		for i := range rv.Len() {

     

       1223
       1223
       -
       			out[i] = rv.Index(i).Interface()

     

       1224
       1224
       -
       		}

     

       1225
       1225
       -
       		return out

     

       1226
       1226
       -
       	}

     

       1227
       1227
       -
       

     

       1228
       1228
       -
       	return []any{f.arg}

     

       1229
       1229
       -
       }

+4 -3

appview/db/follow.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       13
        
       func AddFollow(e Execer, follow *models.Follow) error {

     
···

       134
       135
        
       	return result, nil

     

       135
       136
        
       }

     

       136
       137
        
       

     

       137
       137
       -
       func GetFollows(e Execer, limit int, filters ...filter) ([]models.Follow, error) {

     

       138
       138
       +
       func GetFollows(e Execer, limit int, filters ...orm.Filter) ([]models.Follow, error) {

     

       138
       139
        
       	var follows []models.Follow

     

       139
       140
        
       

     

       140
       141
        
       	var conditions []string

     
···

       191
       192
        
       }

     

       192
       193
        
       

     

       193
       194
        
       func GetFollowers(e Execer, did string) ([]models.Follow, error) {

     

       194
       194
       -
       	return GetFollows(e, 0, FilterEq("subject_did", did))

     

       195
       195
       +
       	return GetFollows(e, 0, orm.FilterEq("subject_did", did))

     

       195
       196
        
       }

     

       196
       197
        
       

     

       197
       198
        
       func GetFollowing(e Execer, did string) ([]models.Follow, error) {

     

       198
       198
       -
       	return GetFollows(e, 0, FilterEq("user_did", did))

     

       199
       199
       +
       	return GetFollows(e, 0, orm.FilterEq("user_did", did))

     

       199
       200
        
       }

     

       200
       201
        
       

     

       201
       202
        
       func getFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]models.FollowStatus, error) {

+168 -36

appview/db/issues.go

···

       10
       10
        
       	"time"

     

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

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

     

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

     

       14
       15
        
       	"tangled.org/core/appview/pagination"

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       15
       17
        
       )

     

       16
       18
        
       

     

       17
       19
        
       func PutIssue(tx *sql.Tx, issue *models.Issue) error {

     
···

       26
       28
        
       

     

       27
       29
        
       	issues, err := GetIssues(

     

       28
       30
        
       		tx,

     

       29
       29
       -
       		FilterEq("did", issue.Did),

     

       30
       30
       -
       		FilterEq("rkey", issue.Rkey),

     

       31
       31
       +
       		orm.FilterEq("did", issue.Did),

     

       32
       32
       +
       		orm.FilterEq("rkey", issue.Rkey),

     

       31
       33
        
       	)

     

       32
       34
        
       	switch {

     

       33
       35
        
       	case err != nil:

     
···

       69
       71
        
       		returning rowid, issue_id

     

       70
       72
        
       	`, issue.RepoAt, issue.Did, issue.Rkey, newIssueId, issue.Title, issue.Body)

     

       71
       73
        
       

     

       72
       72
       -
       	return row.Scan(&issue.Id, &issue.IssueId)

     

       74
       74
       +
       	err = row.Scan(&issue.Id, &issue.IssueId)

     

       75
       75
       +
       	if err != nil {

     

       76
       76
       +
       		return fmt.Errorf("scan row: %w", err)

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       79
       79
       +
       	if err := putReferences(tx, issue.AtUri(), issue.References); err != nil {

     

       80
       80
       +
       		return fmt.Errorf("put reference_links: %w", err)

     

       81
       81
       +
       	}

     

       82
       82
       +
       	return nil

     

       73
       83
        
       }

     

       74
       84
        
       

     

       75
       85
        
       func updateIssue(tx *sql.Tx, issue *models.Issue) error {

     
···

       79
       89
        
       		set title = ?, body = ?, edited = ?

     

       80
       90
        
       		where did = ? and rkey = ?

     

       81
       91
        
       	`, issue.Title, issue.Body, time.Now().Format(time.RFC3339), issue.Did, issue.Rkey)

     

       82
       82
       -
       	return err

     

       92
       92
       +
       	if err != nil {

     

       93
       93
       +
       		return err

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	if err := putReferences(tx, issue.AtUri(), issue.References); err != nil {

     

       97
       97
       +
       		return fmt.Errorf("put reference_links: %w", err)

     

       98
       98
       +
       	}

     

       99
       99
       +
       	return nil

     

       83
       100
        
       }

     

       84
       101
        
       

     

       85
       85
       -
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) {

     

       102
       102
       +
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]models.Issue, error) {

     

       86
       103
        
       	issueMap := make(map[string]*models.Issue) // at-uri -> issue

     

       87
       104
        
       

     

       88
       105
        
       	var conditions []string

     
···

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

     

       99
       116
        
       	}

     

       100
       117
        
       

     

       101
       101
       -
       	pLower := FilterGte("row_num", page.Offset+1)

     

       102
       102
       -
       	pUpper := FilterLte("row_num", page.Offset+page.Limit)

     

       118
       118
       +
       	pLower := orm.FilterGte("row_num", page.Offset+1)

     

       119
       119
       +
       	pUpper := orm.FilterLte("row_num", page.Offset+page.Limit)

     

       103
       120
        
       

     

       104
       104
       -
       	args = append(args, pLower.Arg()...)

     

       105
       105
       -
       	args = append(args, pUpper.Arg()...)

     

       106
       106
       -
       	pagination := " where " + pLower.Condition() + " and " + pUpper.Condition()

     

       121
       121
       +
       	pageClause := ""

     

       122
       122
       +
       	if page.Limit > 0 {

     

       123
       123
       +
       		args = append(args, pLower.Arg()...)

     

       124
       124
       +
       		args = append(args, pUpper.Arg()...)

     

       125
       125
       +
       		pageClause = " where " + pLower.Condition() + " and " + pUpper.Condition()

     

       126
       126
       +
       	}

     

       107
       127
        
       

     

       108
       128
        
       	query := fmt.Sprintf(

     

       109
       129
        
       		`

     
···

       128
       148
        
       		%s

     

       129
       149
        
       		`,

     

       130
       150
        
       		whereClause,

     

       131
       131
       -
       		pagination,

     

       151
       151
       +
       		pageClause,

     

       132
       152
        
       	)

     

       133
       153
        
       

     

       134
       154
        
       	rows, err := e.Query(query, args...)

     
···

       186
       206
        
       		repoAts = append(repoAts, string(issue.RepoAt))

     

       187
       207
        
       	}

     

       188
       208
        
       

     

       189
       189
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoAts))

     

       209
       209
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", repoAts))

     

       190
       210
        
       	if err != nil {

     

       191
       211
        
       		return nil, fmt.Errorf("failed to build repo mappings: %w", err)

     

       192
       212
        
       	}

     
···

       209
       229
        
       	// collect comments

     

       210
       230
        
       	issueAts := slices.Collect(maps.Keys(issueMap))

     

       211
       231
        
       

     

       212
       212
       -
       	comments, err := GetIssueComments(e, FilterIn("issue_at", issueAts))

     

       232
       232
       +
       	comments, err := GetIssueComments(e, orm.FilterIn("issue_at", issueAts))

     

       213
       233
        
       	if err != nil {

     

       214
       234
        
       		return nil, fmt.Errorf("failed to query comments: %w", err)

     

       215
       235
        
       	}

     
···

       221
       241
        
       	}

     

       222
       242
        
       

     

       223
       243
        
       	// collect allLabels for each issue

     

       224
       224
       -
       	allLabels, err := GetLabels(e, FilterIn("subject", issueAts))

     

       244
       244
       +
       	allLabels, err := GetLabels(e, orm.FilterIn("subject", issueAts))

     

       225
       245
        
       	if err != nil {

     

       226
       246
        
       		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       227
       247
        
       	}

     
···

       231
       251
        
       		}

     

       232
       252
        
       	}

     

       233
       253
        
       

     

       254
       254
       +
       	// collect references for each issue

     

       255
       255
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", issueAts))

     

       256
       256
       +
       	if err != nil {

     

       257
       257
       +
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       258
       258
       +
       	}

     

       259
       259
       +
       	for issueAt, references := range allReferencs {

     

       260
       260
       +
       		if issue, ok := issueMap[issueAt.String()]; ok {

     

       261
       261
       +
       			issue.References = references

     

       262
       262
       +
       		}

     

       263
       263
       +
       	}

     

       264
       264
       +
       

     

       234
       265
        
       	var issues []models.Issue

     

       235
       266
        
       	for _, i := range issueMap {

     

       236
       267
        
       		issues = append(issues, *i)

     
···

       243
       274
        
       	return issues, nil

     

       244
       275
        
       }

     

       245
       276
        
       

     

       246
       246
       -
       func GetIssues(e Execer, filters ...filter) ([]models.Issue, error) {

     

       247
       247
       -
       	return GetIssuesPaginated(e, pagination.FirstPage(), filters...)

     

       277
       277
       +
       func GetIssue(e Execer, repoAt syntax.ATURI, issueId int) (*models.Issue, error) {

     

       278
       278
       +
       	issues, err := GetIssuesPaginated(

     

       279
       279
       +
       		e,

     

       280
       280
       +
       		pagination.Page{},

     

       281
       281
       +
       		orm.FilterEq("repo_at", repoAt),

     

       282
       282
       +
       		orm.FilterEq("issue_id", issueId),

     

       283
       283
       +
       	)

     

       284
       284
       +
       	if err != nil {

     

       285
       285
       +
       		return nil, err

     

       286
       286
       +
       	}

     

       287
       287
       +
       	if len(issues) != 1 {

     

       288
       288
       +
       		return nil, sql.ErrNoRows

     

       289
       289
       +
       	}

     

       290
       290
       +
       

     

       291
       291
       +
       	return &issues[0], nil

     

       292
       292
       +
       }

     

       293
       293
       +
       

     

       294
       294
       +
       func GetIssues(e Execer, filters ...orm.Filter) ([]models.Issue, error) {

     

       295
       295
       +
       	return GetIssuesPaginated(e, pagination.Page{}, filters...)

     

       248
       296
        
       }

     

       249
       297
        
       

     

       250
       250
       -
       func AddIssueComment(e Execer, c models.IssueComment) (int64, error) {

     

       251
       251
       -
       	result, err := e.Exec(

     

       298
       298
       +
       // GetIssueIDs gets list of all existing issue's IDs

     

       299
       299
       +
       func GetIssueIDs(e Execer, opts models.IssueSearchOptions) ([]int64, error) {

     

       300
       300
       +
       	var ids []int64

     

       301
       301
       +
       

     

       302
       302
       +
       	var filters []orm.Filter

     

       303
       303
       +
       	openValue := 0

     

       304
       304
       +
       	if opts.IsOpen {

     

       305
       305
       +
       		openValue = 1

     

       306
       306
       +
       	}

     

       307
       307
       +
       	filters = append(filters, orm.FilterEq("open", openValue))

     

       308
       308
       +
       	if opts.RepoAt != "" {

     

       309
       309
       +
       		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       310
       310
       +
       	}

     

       311
       311
       +
       

     

       312
       312
       +
       	var conditions []string

     

       313
       313
       +
       	var args []any

     

       314
       314
       +
       

     

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

     

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

     

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

     

       318
       318
       +
       	}

     

       319
       319
       +
       

     

       320
       320
       +
       	whereClause := ""

     

       321
       321
       +
       	if conditions != nil {

     

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

     

       323
       323
       +
       	}

     

       324
       324
       +
       	query := fmt.Sprintf(

     

       325
       325
       +
       		`

     

       326
       326
       +
       		select

     

       327
       327
       +
       			id

     

       328
       328
       +
       		from

     

       329
       329
       +
       			issues

     

       330
       330
       +
       		%s

     

       331
       331
       +
       		limit ? offset ?`,

     

       332
       332
       +
       		whereClause,

     

       333
       333
       +
       	)

     

       334
       334
       +
       	args = append(args, opts.Page.Limit, opts.Page.Offset)

     

       335
       335
       +
       	rows, err := e.Query(query, args...)

     

       336
       336
       +
       	if err != nil {

     

       337
       337
       +
       		return nil, err

     

       338
       338
       +
       	}

     

       339
       339
       +
       	defer rows.Close()

     

       340
       340
       +
       

     

       341
       341
       +
       	for rows.Next() {

     

       342
       342
       +
       		var id int64

     

       343
       343
       +
       		err := rows.Scan(&id)

     

       344
       344
       +
       		if err != nil {

     

       345
       345
       +
       			return nil, err

     

       346
       346
       +
       		}

     

       347
       347
       +
       

     

       348
       348
       +
       		ids = append(ids, id)

     

       349
       349
       +
       	}

     

       350
       350
       +
       

     

       351
       351
       +
       	return ids, nil

     

       352
       352
       +
       }

     

       353
       353
       +
       

     

       354
       354
       +
       func AddIssueComment(tx *sql.Tx, c models.IssueComment) (int64, error) {

     

       355
       355
       +
       	result, err := tx.Exec(

     

       252
       356
        
       		`insert into issue_comments (

     

       253
       357
        
       			did,

     

       254
       358
        
       			rkey,

     
···

       287
       391
        
       		return 0, err

     

       288
       392
        
       	}

     

       289
       393
        
       

     

       394
       394
       +
       	if err := putReferences(tx, c.AtUri(), c.References); err != nil {

     

       395
       395
       +
       		return 0, fmt.Errorf("put reference_links: %w", err)

     

       396
       396
       +
       	}

     

       397
       397
       +
       

     

       290
       398
        
       	return id, nil

     

       291
       399
        
       }

     

       292
       400
        
       

     

       293
       293
       -
       func DeleteIssueComments(e Execer, filters ...filter) error {

     

       401
       401
       +
       func DeleteIssueComments(e Execer, filters ...orm.Filter) error {

     

       294
       402
        
       	var conditions []string

     

       295
       403
        
       	var args []any

     

       296
       404
        
       	for _, filter := range filters {

     
···

       309
       417
        
       	return err

     

       310
       418
        
       }

     

       311
       419
        
       

     

       312
       312
       -
       func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) {

     

       313
       313
       -
       	var comments []models.IssueComment

     

       420
       420
       +
       func GetIssueComments(e Execer, filters ...orm.Filter) ([]models.IssueComment, error) {

     

       421
       421
       +
       	commentMap := make(map[string]*models.IssueComment)

     

       314
       422
        
       

     

       315
       423
        
       	var conditions []string

     

       316
       424
        
       	var args []any

     
···

       389
       497
        
       			comment.ReplyTo = &replyTo.V

     

       390
       498
        
       		}

     

       391
       499
        
       

     

       392
       392
       -
       		comments = append(comments, comment)

     

       500
       500
       +
       		atUri := comment.AtUri().String()

     

       501
       501
       +
       		commentMap[atUri] = &comment

     

       393
       502
        
       	}

     

       394
       503
        
       

     

       395
       504
        
       	if err = rows.Err(); err != nil {

     

       396
       505
        
       		return nil, err

     

       397
       506
        
       	}

     

       398
       507
        
       

     

       508
       508
       +
       	// collect references for each comments

     

       509
       509
       +
       	commentAts := slices.Collect(maps.Keys(commentMap))

     

       510
       510
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       511
       511
       +
       	if err != nil {

     

       512
       512
       +
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       513
       513
       +
       	}

     

       514
       514
       +
       	for commentAt, references := range allReferencs {

     

       515
       515
       +
       		if comment, ok := commentMap[commentAt.String()]; ok {

     

       516
       516
       +
       			comment.References = references

     

       517
       517
       +
       		}

     

       518
       518
       +
       	}

     

       519
       519
       +
       

     

       520
       520
       +
       	var comments []models.IssueComment

     

       521
       521
       +
       	for _, c := range commentMap {

     

       522
       522
       +
       		comments = append(comments, *c)

     

       523
       523
       +
       	}

     

       524
       524
       +
       

     

       525
       525
       +
       	sort.Slice(comments, func(i, j int) bool {

     

       526
       526
       +
       		return comments[i].Created.After(comments[j].Created)

     

       527
       527
       +
       	})

     

       528
       528
       +
       

     

       399
       529
        
       	return comments, nil

     

       400
       530
        
       }

     

       401
       531
        
       

     

       402
       402
       -
       func DeleteIssues(e Execer, filters ...filter) error {

     

       403
       403
       -
       	var conditions []string

     

       404
       404
       -
       	var args []any

     

       405
       405
       -
       	for _, filter := range filters {

     

       406
       406
       -
       		conditions = append(conditions, filter.Condition())

     

       407
       407
       -
       		args = append(args, filter.Arg()...)

     

       532
       532
       +
       func DeleteIssues(tx *sql.Tx, did, rkey string) error {

     

       533
       533
       +
       	_, err := tx.Exec(

     

       534
       534
       +
       		`delete from issues

     

       535
       535
       +
       		where did = ? and rkey = ?`,

     

       536
       536
       +
       		did,

     

       537
       537
       +
       		rkey,

     

       538
       538
       +
       	)

     

       539
       539
       +
       	if err != nil {

     

       540
       540
       +
       		return fmt.Errorf("delete issue: %w", err)

     

       408
       541
        
       	}

     

       409
       542
        
       

     

       410
       410
       -
       	whereClause := ""

     

       411
       411
       -
       	if conditions != nil {

     

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

     

       543
       543
       +
       	uri := syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", did, tangled.RepoIssueNSID, rkey))

     

       544
       544
       +
       	err = deleteReferences(tx, uri)

     

       545
       545
       +
       	if err != nil {

     

       546
       546
       +
       		return fmt.Errorf("delete reference_links: %w", err)

     

       413
       547
        
       	}

     

       414
       548
        
       

     

       415
       415
       -
       	query := fmt.Sprintf(`delete from issues %s`, whereClause)

     

       416
       416
       -
       	_, err := e.Exec(query, args...)

     

       417
       417
       -
       	return err

     

       549
       549
       +
       	return nil

     

       418
       550
        
       }

     

       419
       551
        
       

     

       420
       420
       -
       func CloseIssues(e Execer, filters ...filter) error {

     

       552
       552
       +
       func CloseIssues(e Execer, filters ...orm.Filter) error {

     

       421
       553
        
       	var conditions []string

     

       422
       554
        
       	var args []any

     

       423
       555
        
       	for _, filter := range filters {

     
···

       435
       567
        
       	return err

     

       436
       568
        
       }

     

       437
       569
        
       

     

       438
       438
       -
       func ReopenIssues(e Execer, filters ...filter) error {

     

       570
       570
       +
       func ReopenIssues(e Execer, filters ...orm.Filter) error {

     

       439
       571
        
       	var conditions []string

     

       440
       572
        
       	var args []any

     

       441
       573
        
       	for _, filter := range filters {

+8 -7

appview/db/label.go

···

       10
       10
        
       

     

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
       +
       	"tangled.org/core/orm"

     

       13
       14
        
       )

     

       14
       15
        
       

     

       15
       16
        
       // no updating type for now

     
···

       59
       60
        
       	return id, nil

     

       60
       61
        
       }

     

       61
       62
        
       

     

       62
       62
       -
       func DeleteLabelDefinition(e Execer, filters ...filter) error {

     

       63
       63
       +
       func DeleteLabelDefinition(e Execer, filters ...orm.Filter) error {

     

       63
       64
        
       	var conditions []string

     

       64
       65
        
       	var args []any

     

       65
       66
        
       	for _, filter := range filters {

     
···

       75
       76
        
       	return err

     

       76
       77
        
       }

     

       77
       78
        
       

     

       78
       78
       -
       func GetLabelDefinitions(e Execer, filters ...filter) ([]models.LabelDefinition, error) {

     

       79
       79
       +
       func GetLabelDefinitions(e Execer, filters ...orm.Filter) ([]models.LabelDefinition, error) {

     

       79
       80
        
       	var labelDefinitions []models.LabelDefinition

     

       80
       81
        
       	var conditions []string

     

       81
       82
        
       	var args []any

     
···

       167
       168
        
       }

     

       168
       169
        
       

     

       169
       170
        
       // helper to get exactly one label def

     

       170
       170
       -
       func GetLabelDefinition(e Execer, filters ...filter) (*models.LabelDefinition, error) {

     

       171
       171
       +
       func GetLabelDefinition(e Execer, filters ...orm.Filter) (*models.LabelDefinition, error) {

     

       171
       172
        
       	labels, err := GetLabelDefinitions(e, filters...)

     

       172
       173
        
       	if err != nil {

     

       173
       174
        
       		return nil, err

     
···

       227
       228
        
       	return id, nil

     

       228
       229
        
       }

     

       229
       230
        
       

     

       230
       230
       -
       func GetLabelOps(e Execer, filters ...filter) ([]models.LabelOp, error) {

     

       231
       231
       +
       func GetLabelOps(e Execer, filters ...orm.Filter) ([]models.LabelOp, error) {

     

       231
       232
        
       	var labelOps []models.LabelOp

     

       232
       233
        
       	var conditions []string

     

       233
       234
        
       	var args []any

     
···

       302
       303
        
       }

     

       303
       304
        
       

     

       304
       305
        
       // get labels for a given list of subject URIs

     

       305
       305
       -
       func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]models.LabelState, error) {

     

       306
       306
       +
       func GetLabels(e Execer, filters ...orm.Filter) (map[syntax.ATURI]models.LabelState, error) {

     

       306
       307
        
       	ops, err := GetLabelOps(e, filters...)

     

       307
       308
        
       	if err != nil {

     

       308
       309
        
       		return nil, err

     
···

       322
       323
        
       	}

     

       323
       324
        
       	labelAts := slices.Collect(maps.Keys(labelAtSet))

     

       324
       325
        
       

     

       325
       325
       -
       	actx, err := NewLabelApplicationCtx(e, FilterIn("at_uri", labelAts))

     

       326
       326
       +
       	actx, err := NewLabelApplicationCtx(e, orm.FilterIn("at_uri", labelAts))

     

       326
       327
        
       	if err != nil {

     

       327
       328
        
       		return nil, err

     

       328
       329
        
       	}

     
···

       338
       339
        
       	return results, nil

     

       339
       340
        
       }

     

       340
       341
        
       

     

       341
       341
       -
       func NewLabelApplicationCtx(e Execer, filters ...filter) (*models.LabelApplicationCtx, error) {

     

       342
       342
       +
       func NewLabelApplicationCtx(e Execer, filters ...orm.Filter) (*models.LabelApplicationCtx, error) {

     

       342
       343
        
       	labels, err := GetLabelDefinitions(e, filters...)

     

       343
       344
        
       	if err != nil {

     

       344
       345
        
       		return nil, err

+5 -4

appview/db/language.go

···

       7
       7
        
       

     

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

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetRepoLanguages(e Execer, filters ...filter) ([]models.RepoLanguage, error) {

     

       13
       13
       +
       func GetRepoLanguages(e Execer, filters ...orm.Filter) ([]models.RepoLanguage, error) {

     

       13
       14
        
       	var conditions []string

     

       14
       15
        
       	var args []any

     

       15
       16
        
       	for _, filter := range filters {

     
···

       85
       86
        
       	return nil

     

       86
       87
        
       }

     

       87
       88
        
       

     

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

     

       89
       89
       +
       func DeleteRepoLanguages(e Execer, filters ...orm.Filter) error {

     

       89
       90
        
       	var conditions []string

     

       90
       91
        
       	var args []any

     

       91
       92
        
       	for _, filter := range filters {

     
···

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

     

       108
       109
        
       	err := DeleteRepoLanguages(

     

       109
       110
        
       		tx,

     

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

     

       111
       111
       -
       		FilterEq("ref", ref),

     

       111
       111
       +
       		orm.FilterEq("repo_at", repoAt),

     

       112
       112
       +
       		orm.FilterEq("ref", ref),

     

       112
       113
        
       	)

     

       113
       114
        
       	if err != nil {

     

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

+36 -22

appview/db/notifications.go

···

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       func CreateNotification(e Execer, notification *models.Notification) error {

     
···

       44
       45
        
       }

     

       45
       46
        
       

     

       46
       47
        
       // GetNotificationsPaginated retrieves notifications with filters and pagination

     

       47
       47
       -
       func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...filter) ([]*models.Notification, error) {

     

       48
       48
       +
       func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.Notification, error) {

     

       48
       49
        
       	var conditions []string

     

       49
       50
        
       	var args []any

     

       50
       51
        
       

     
···

       59
       60
        
       		for _, condition := range conditions[1:] {

     

       60
       61
        
       			whereClause += " AND " + condition

     

       61
       62
        
       		}

     

       63
       63
       +
       	}

     

       64
       64
       +
       	pageClause := ""

     

       65
       65
       +
       	if page.Limit > 0 {

     

       66
       66
       +
       		pageClause = " limit ? offset ? "

     

       67
       67
       +
       		args = append(args, page.Limit, page.Offset)

     

       62
       68
        
       	}

     

       63
       69
        
       

     

       64
       70
        
       	query := fmt.Sprintf(`

     
···

       66
       72
        
       		from notifications

     

       67
       73
        
       		%s

     

       68
       74
        
       		order by created desc

     

       69
       69
       -
       		limit ? offset ?

     

       70
       70
       -
       	`, whereClause)

     

       71
       71
       -
       

     

       72
       72
       -
       	args = append(args, page.Limit, page.Offset)

     

       75
       75
       +
       		%s

     

       76
       76
       +
       	`, whereClause, pageClause)

     

       73
       77
        
       

     

       74
       78
        
       	rows, err := e.QueryContext(context.Background(), query, args...)

     

       75
       79
        
       	if err != nil {

     
···

       110
       114
        
       }

     

       111
       115
        
       

     

       112
       116
        
       // GetNotificationsWithEntities retrieves notifications with their related entities

     

       113
       113
       -
       func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...filter) ([]*models.NotificationWithEntity, error) {

     

       117
       117
       +
       func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...orm.Filter) ([]*models.NotificationWithEntity, error) {

     

       114
       118
        
       	var conditions []string

     

       115
       119
        
       	var args []any

     

       116
       120
        
       

     
···

       131
       135
        
       		select

     

       132
       136
        
       			n.id, n.recipient_did, n.actor_did, n.type, n.entity_type, n.entity_id,

     

       133
       137
        
       			n.read, n.created, n.repo_id, n.issue_id, n.pull_id,

     

       134
       134
       -
       			r.id as r_id, r.did as r_did, r.name as r_name, r.description as r_description,

     

       138
       138
       +
       			r.id as r_id, r.did as r_did, r.name as r_name, r.description as r_description, r.website as r_website, r.topics as r_topics,

     

       135
       139
        
       			i.id as i_id, i.did as i_did, i.issue_id as i_issue_id, i.title as i_title, i.open as i_open,

     

       136
       140
        
       			p.id as p_id, p.owner_did as p_owner_did, p.pull_id as p_pull_id, p.title as p_title, p.state as p_state

     

       137
       141
        
       		from notifications n

     
···

       160
       164
        
       		var issue models.Issue

     

       161
       165
        
       		var pull models.Pull

     

       162
       166
        
       		var rId, iId, pId sql.NullInt64

     

       163
       163
       -
       		var rDid, rName, rDescription sql.NullString

     

       167
       167
       +
       		var rDid, rName, rDescription, rWebsite, rTopicStr sql.NullString

     

       164
       168
        
       		var iDid sql.NullString

     

       165
       169
        
       		var iIssueId sql.NullInt64

     

       166
       170
        
       		var iTitle sql.NullString

     
···

       173
       177
        
       		err := rows.Scan(

     

       174
       178
        
       			&n.ID, &n.RecipientDid, &n.ActorDid, &typeStr, &n.EntityType, &n.EntityId,

     

       175
       179
        
       			&n.Read, &createdStr, &n.RepoId, &n.IssueId, &n.PullId,

     

       176
       176
       -
       			&rId, &rDid, &rName, &rDescription,

     

       180
       180
       +
       			&rId, &rDid, &rName, &rDescription, &rWebsite, &rTopicStr,

     

       177
       181
        
       			&iId, &iDid, &iIssueId, &iTitle, &iOpen,

     

       178
       182
        
       			&pId, &pOwnerDid, &pPullId, &pTitle, &pState,

     

       179
       183
        
       		)

     
···

       201
       205
        
       			if rDescription.Valid {

     

       202
       206
        
       				repo.Description = rDescription.String

     

       203
       207
        
       			}

     

       208
       208
       +
       			if rWebsite.Valid {

     

       209
       209
       +
       				repo.Website = rWebsite.String

     

       210
       210
       +
       			}

     

       211
       211
       +
       			if rTopicStr.Valid {

     

       212
       212
       +
       				repo.Topics = strings.Fields(rTopicStr.String)

     

       213
       213
       +
       			}

     

       204
       214
        
       			nwe.Repo = &repo

     

       205
       215
        
       		}

     

       206
       216
        
       

     
···

       247
       257
        
       }

     

       248
       258
        
       

     

       249
       259
        
       // GetNotifications retrieves notifications with filters

     

       250
       250
       -
       func GetNotifications(e Execer, filters ...filter) ([]*models.Notification, error) {

     

       260
       260
       +
       func GetNotifications(e Execer, filters ...orm.Filter) ([]*models.Notification, error) {

     

       251
       261
        
       	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       252
       262
        
       }

     

       253
       263
        
       

     

       254
       254
       -
       func CountNotifications(e Execer, filters ...filter) (int64, error) {

     

       264
       264
       +
       func CountNotifications(e Execer, filters ...orm.Filter) (int64, error) {

     

       255
       265
        
       	var conditions []string

     

       256
       266
        
       	var args []any

     

       257
       267
        
       	for _, filter := range filters {

     
···

       276
       286
        
       }

     

       277
       287
        
       

     

       278
       288
        
       func MarkNotificationRead(e Execer, notificationID int64, userDID string) error {

     

       279
       279
       -
       	idFilter := FilterEq("id", notificationID)

     

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

     

       289
       289
       +
       	idFilter := orm.FilterEq("id", notificationID)

     

       290
       290
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       281
       291
        
       

     

       282
       292
        
       	query := fmt.Sprintf(`

     

       283
       293
        
       		UPDATE notifications

     
···

       305
       315
        
       }

     

       306
       316
        
       

     

       307
       317
        
       func MarkAllNotificationsRead(e Execer, userDID string) error {

     

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

     

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

     

       318
       318
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       319
       319
       +
       	readFilter := orm.FilterEq("read", 0)

     

       310
       320
        
       

     

       311
       321
        
       	query := fmt.Sprintf(`

     

       312
       322
        
       		UPDATE notifications

     
···

       325
       335
        
       }

     

       326
       336
        
       

     

       327
       337
        
       func DeleteNotification(e Execer, notificationID int64, userDID string) error {

     

       328
       328
       -
       	idFilter := FilterEq("id", notificationID)

     

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

     

       338
       338
       +
       	idFilter := orm.FilterEq("id", notificationID)

     

       339
       339
       +
       	recipientFilter := orm.FilterEq("recipient_did", userDID)

     

       330
       340
        
       

     

       331
       341
        
       	query := fmt.Sprintf(`

     

       332
       342
        
       		DELETE FROM notifications

     
···

       353
       363
        
       }

     

       354
       364
        
       

     

       355
       365
        
       func GetNotificationPreference(e Execer, userDid string) (*models.NotificationPreferences, error) {

     

       356
       356
       -
       	prefs, err := GetNotificationPreferences(e, FilterEq("user_did", userDid))

     

       366
       366
       +
       	prefs, err := GetNotificationPreferences(e, orm.FilterEq("user_did", userDid))

     

       357
       367
        
       	if err != nil {

     

       358
       368
        
       		return nil, err

     

       359
       369
        
       	}

     
···

       366
       376
        
       	return p, nil

     

       367
       377
        
       }

     

       368
       378
        
       

     

       369
       369
       -
       func GetNotificationPreferences(e Execer, filters ...filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       379
       379
       +
       func GetNotificationPreferences(e Execer, filters ...orm.Filter) (map[syntax.DID]*models.NotificationPreferences, error) {

     

       370
       380
        
       	prefsMap := make(map[syntax.DID]*models.NotificationPreferences)

     

       371
       381
        
       

     

       372
       382
        
       	var conditions []string

     
···

       391
       401
        
       			pull_created,

     

       392
       402
        
       			pull_commented,

     

       393
       403
        
       			followed,

     

       404
       404
       +
       			user_mentioned,

     

       394
       405
        
       			pull_merged,

     

       395
       406
        
       			issue_closed,

     

       396
       407
        
       			email_notifications

     
···

       416
       427
        
       			&prefs.PullCreated,

     

       417
       428
        
       			&prefs.PullCommented,

     

       418
       429
        
       			&prefs.Followed,

     

       430
       430
       +
       			&prefs.UserMentioned,

     

       419
       431
        
       			&prefs.PullMerged,

     

       420
       432
        
       			&prefs.IssueClosed,

     

       421
       433
        
       			&prefs.EmailNotifications,

     
···

       437
       449
        
       	query := `

     

       438
       450
        
       		INSERT OR REPLACE INTO notification_preferences

     

       439
       451
        
       		(user_did, repo_starred, issue_created, issue_commented, pull_created,

     

       440
       440
       -
       		 pull_commented, followed, pull_merged, issue_closed, email_notifications)

     

       441
       441
       -
       		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

     

       452
       452
       +
       		 pull_commented, followed, user_mentioned, pull_merged, issue_closed,

     

       453
       453
       +
       		 email_notifications)

     

       454
       454
       +
       		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

     

       442
       455
        
       	`

     

       443
       456
        
       

     

       444
       457
        
       	result, err := d.DB.ExecContext(ctx, query,

     
···

       449
       462
        
       		prefs.PullCreated,

     

       450
       463
        
       		prefs.PullCommented,

     

       451
       464
        
       		prefs.Followed,

     

       465
       465
       +
       		prefs.UserMentioned,

     

       452
       466
        
       		prefs.PullMerged,

     

       453
       467
        
       		prefs.IssueClosed,

     

       454
       468
        
       		prefs.EmailNotifications,

     
···

       470
       484
        
       

     

       471
       485
        
       func (d *DB) ClearOldNotifications(ctx context.Context, olderThan time.Duration) error {

     

       472
       486
        
       	cutoff := time.Now().Add(-olderThan)

     

       473
       473
       -
       	createdFilter := FilterLte("created", cutoff)

     

       487
       487
       +
       	createdFilter := orm.FilterLte("created", cutoff)

     

       474
       488
        
       

     

       475
       489
        
       	query := fmt.Sprintf(`

     

       476
       490
        
       		DELETE FROM notifications

+9 -6

appview/db/pipeline.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetPipelines(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       13
       13
       +
       func GetPipelines(e Execer, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       13
       14
        
       	var pipelines []models.Pipeline

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       168
       169
        
       

     

       169
       170
        
       // this is a mega query, but the most useful one:

     

       170
       171
        
       // get N pipelines, for each one get the latest status of its N workflows

     

       171
       171
       -
       func GetPipelineStatuses(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       172
       172
       +
       func GetPipelineStatuses(e Execer, limit int, filters ...orm.Filter) ([]models.Pipeline, error) {

     

       172
       173
        
       	var conditions []string

     

       173
       174
        
       	var args []any

     

       174
       175
        
       	for _, filter := range filters {

     

       175
       175
       -
       		filter.key = "p." + filter.key // the table is aliased in the query to `p`

     

       176
       176
       +
       		filter.Key = "p." + filter.Key // the table is aliased in the query to `p`

     

       176
       177
        
       		conditions = append(conditions, filter.Condition())

     

       177
       178
        
       		args = append(args, filter.Arg()...)

     

       178
       179
        
       	}

     
···

       205
       206
        
       		join

     

       206
       207
        
       			triggers t ON p.trigger_id = t.id

     

       207
       208
        
       		%s

     

       208
       208
       -
       	`, whereClause)

     

       209
       209
       +
       		order by p.created desc

     

       210
       210
       +
       		limit %d

     

       211
       211
       +
       	`, whereClause, limit)

     

       209
       212
        
       

     

       210
       213
        
       	rows, err := e.Query(query, args...)

     

       211
       214
        
       	if err != nil {

     
···

       262
       265
        
       	conditions = nil

     

       263
       266
        
       	args = nil

     

       264
       267
        
       	for _, p := range pipelines {

     

       265
       265
       -
       		knotFilter := FilterEq("pipeline_knot", p.Knot)

     

       266
       266
       -
       		rkeyFilter := FilterEq("pipeline_rkey", p.Rkey)

     

       268
       268
       +
       		knotFilter := orm.FilterEq("pipeline_knot", p.Knot)

     

       269
       269
       +
       		rkeyFilter := orm.FilterEq("pipeline_rkey", p.Rkey)

     

       267
       270
        
       		conditions = append(conditions, fmt.Sprintf("(%s and %s)", knotFilter.Condition(), rkeyFilter.Condition()))

     

       268
       271
        
       		args = append(args, p.Knot)

     

       269
       272
        
       		args = append(args, p.Rkey)

+32 -11

appview/db/profile.go

···

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
        
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       const TimeframeMonths = 7

     
···

       44
       45
        
       

     

       45
       46
        
       	issues, err := GetIssues(

     

       46
       47
        
       		e,

     

       47
       47
       -
       		FilterEq("did", forDid),

     

       48
       48
       -
       		FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       48
       48
       +
       		orm.FilterEq("did", forDid),

     

       49
       49
       +
       		orm.FilterGte("created", time.Now().AddDate(0, -TimeframeMonths, 0)),

     

       49
       50
        
       	)

     

       50
       51
        
       	if err != nil {

     

       51
       52
        
       		return nil, fmt.Errorf("error getting issues by owner did: %w", err)

     
···

       65
       66
        
       		*items = append(*items, &issue)

     

       66
       67
        
       	}

     

       67
       68
        
       

     

       68
       68
       -
       	repos, err := GetRepos(e, 0, FilterEq("did", forDid))

     

       69
       69
       +
       	repos, err := GetRepos(e, 0, orm.FilterEq("did", forDid))

     

       69
       70
        
       	if err != nil {

     

       70
       71
        
       		return nil, fmt.Errorf("error getting all repos by did: %w", err)

     

       71
       72
        
       	}

     
···

       129
       130
        
       			did,

     

       130
       131
        
       			description,

     

       131
       132
        
       			include_bluesky,

     

       132
       132
       -
       			location

     

       133
       133
       +
       			location,

     

       134
       134
       +
       			pronouns

     

       133
       135
        
       		)

     

       134
       134
       -
       		values (?, ?, ?, ?)`,

     

       136
       136
       +
       		values (?, ?, ?, ?, ?)`,

     

       135
       137
        
       		profile.Did,

     

       136
       138
        
       		profile.Description,

     

       137
       139
        
       		includeBskyValue,

     

       138
       140
        
       		profile.Location,

     

       141
       141
       +
       		profile.Pronouns,

     

       139
       142
        
       	)

     

       140
       143
        
       

     

       141
       144
        
       	if err != nil {

     
···

       197
       200
        
       	return tx.Commit()

     

       198
       201
        
       }

     

       199
       202
        
       

     

       200
       200
       -
       func GetProfiles(e Execer, filters ...filter) (map[string]*models.Profile, error) {

     

       203
       203
       +
       func GetProfiles(e Execer, filters ...orm.Filter) (map[string]*models.Profile, error) {

     

       201
       204
        
       	var conditions []string

     

       202
       205
        
       	var args []any

     

       203
       206
        
       	for _, filter := range filters {

     
···

       216
       219
        
       			did,

     

       217
       220
        
       			description,

     

       218
       221
        
       			include_bluesky,

     

       219
       219
       -
       			location

     

       222
       222
       +
       			location,

     

       223
       223
       +
       			pronouns

     

       220
       224
        
       		from

     

       221
       225
        
       			profile

     

       222
       226
        
       		%s`,

     
···

       231
       235
        
       	for rows.Next() {

     

       232
       236
        
       		var profile models.Profile

     

       233
       237
        
       		var includeBluesky int

     

       238
       238
       +
       		var pronouns sql.Null[string]

     

       234
       239
        
       

     

       235
       235
       -
       		err = rows.Scan(&profile.ID, &profile.Did, &profile.Description, &includeBluesky, &profile.Location)

     

       240
       240
       +
       		err = rows.Scan(&profile.ID, &profile.Did, &profile.Description, &includeBluesky, &profile.Location, &pronouns)

     

       236
       241
        
       		if err != nil {

     

       237
       242
        
       			return nil, err

     

       238
       243
        
       		}

     
···

       241
       246
        
       			profile.IncludeBluesky = true

     

       242
       247
        
       		}

     

       243
       248
        
       

     

       249
       249
       +
       		if pronouns.Valid {

     

       250
       250
       +
       			profile.Pronouns = pronouns.V

     

       251
       251
       +
       		}

     

       252
       252
       +
       

     

       244
       253
        
       		profileMap[profile.Did] = &profile

     

       245
       254
        
       	}

     

       246
       255
        
       	if err = rows.Err(); err != nil {

     
···

       302
       311
        
       

     

       303
       312
        
       func GetProfile(e Execer, did string) (*models.Profile, error) {

     

       304
       313
        
       	var profile models.Profile

     

       314
       314
       +
       	var pronouns sql.Null[string]

     

       315
       315
       +
       

     

       305
       316
        
       	profile.Did = did

     

       306
       317
        
       

     

       307
       318
        
       	includeBluesky := 0

     

       319
       319
       +
       

     

       308
       320
        
       	err := e.QueryRow(

     

       309
       309
       -
       		`select description, include_bluesky, location from profile where did = ?`,

     

       321
       321
       +
       		`select description, include_bluesky, location, pronouns from profile where did = ?`,

     

       310
       322
        
       		did,

     

       311
       311
       -
       	).Scan(&profile.Description, &includeBluesky, &profile.Location)

     

       323
       323
       +
       	).Scan(&profile.Description, &includeBluesky, &profile.Location, &pronouns)

     

       312
       324
        
       	if err == sql.ErrNoRows {

     

       313
       325
        
       		profile := models.Profile{}

     

       314
       326
        
       		profile.Did = did

     
···

       323
       335
        
       		profile.IncludeBluesky = true

     

       324
       336
        
       	}

     

       325
       337
        
       

     

       338
       338
       +
       	if pronouns.Valid {

     

       339
       339
       +
       		profile.Pronouns = pronouns.V

     

       340
       340
       +
       	}

     

       341
       341
       +
       

     

       326
       342
        
       	rows, err := e.Query(`select link from profile_links where did = ?`, did)

     

       327
       343
        
       	if err != nil {

     

       328
       344
        
       		return nil, err

     
···

       414
       430
        
       		return fmt.Errorf("Entered location is too long.")

     

       415
       431
        
       	}

     

       416
       432
        
       

     

       433
       433
       +
       	// ensure pronouns are not too long

     

       434
       434
       +
       	if len(profile.Pronouns) > 40 {

     

       435
       435
       +
       		return fmt.Errorf("Entered pronouns are too long.")

     

       436
       436
       +
       	}

     

       437
       437
       +
       

     

       417
       438
        
       	// ensure links are in order

     

       418
       439
        
       	err := validateLinks(profile)

     

       419
       440
        
       	if err != nil {

     
···

       421
       442
        
       	}

     

       422
       443
        
       

     

       423
       444
        
       	// ensure all pinned repos are either own repos or collaborating repos

     

       424
       424
       -
       	repos, err := GetRepos(e, 0, FilterEq("did", profile.Did))

     

       445
       445
       +
       	repos, err := GetRepos(e, 0, orm.FilterEq("did", profile.Did))

     

       425
       446
        
       	if err != nil {

     

       426
       447
        
       		log.Printf("getting repos for %s: %s", profile.Did, err)

     

       427
       448
        
       	}

+132 -26

appview/db/pulls.go

···

       13
       13
        
       

     

       14
       14
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

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

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       16
       17
        
       )

     

       17
       18
        
       

     

       18
       19
        
       func NewPull(tx *sql.Tx, pull *models.Pull) error {

     
···

       92
       93
        
       	_, err = tx.Exec(`

     

       93
       94
        
       		insert into pull_submissions (pull_at, round_number, patch, combined, source_rev)

     

       94
       95
        
       		values (?, ?, ?, ?, ?)

     

       95
       95
       -
       	`, pull.PullAt(), 0, pull.Submissions[0].Patch, pull.Submissions[0].Combined, pull.Submissions[0].SourceRev)

     

       96
       96
       -
       	return err

     

       96
       96
       +
       	`, pull.AtUri(), 0, pull.Submissions[0].Patch, pull.Submissions[0].Combined, pull.Submissions[0].SourceRev)

     

       97
       97
       +
       	if err != nil {

     

       98
       98
       +
       		return err

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	if err := putReferences(tx, pull.AtUri(), pull.References); err != nil {

     

       102
       102
       +
       		return fmt.Errorf("put reference_links: %w", err)

     

       103
       103
       +
       	}

     

       104
       104
       +
       

     

       105
       105
       +
       	return nil

     

       97
       106
        
       }

     

       98
       107
        
       

     

       99
       108
        
       func GetPullAt(e Execer, repoAt syntax.ATURI, pullId int) (syntax.ATURI, error) {

     
···

       101
       110
        
       	if err != nil {

     

       102
       111
        
       		return "", err

     

       103
       112
        
       	}

     

       104
       104
       -
       	return pull.PullAt(), err

     

       113
       113
       +
       	return pull.AtUri(), err

     

       105
       114
        
       }

     

       106
       115
        
       

     

       107
       116
        
       func NextPullId(e Execer, repoAt syntax.ATURI) (int, error) {

     
···

       110
       119
        
       	return pullId - 1, err

     

       111
       120
        
       }

     

       112
       121
        
       

     

       113
       113
       -
       func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*models.Pull, error) {

     

       122
       122
       +
       func GetPullsWithLimit(e Execer, limit int, filters ...orm.Filter) ([]*models.Pull, error) {

     

       114
       123
        
       	pulls := make(map[syntax.ATURI]*models.Pull)

     

       115
       124
        
       

     

       116
       125
        
       	var conditions []string

     
···

       214
       223
        
       			pull.ParentChangeId = parentChangeId.String

     

       215
       224
        
       		}

     

       216
       225
        
       

     

       217
       217
       -
       		pulls[pull.PullAt()] = &pull

     

       226
       226
       +
       		pulls[pull.AtUri()] = &pull

     

       218
       227
        
       	}

     

       219
       228
        
       

     

       220
       229
        
       	var pullAts []syntax.ATURI

     

       221
       230
        
       	for _, p := range pulls {

     

       222
       222
       -
       		pullAts = append(pullAts, p.PullAt())

     

       231
       231
       +
       		pullAts = append(pullAts, p.AtUri())

     

       223
       232
        
       	}

     

       224
       224
       -
       	submissionsMap, err := GetPullSubmissions(e, FilterIn("pull_at", pullAts))

     

       233
       233
       +
       	submissionsMap, err := GetPullSubmissions(e, orm.FilterIn("pull_at", pullAts))

     

       225
       234
        
       	if err != nil {

     

       226
       235
        
       		return nil, fmt.Errorf("failed to get submissions: %w", err)

     

       227
       236
        
       	}

     
···

       233
       242
        
       	}

     

       234
       243
        
       

     

       235
       244
        
       	// collect allLabels for each issue

     

       236
       236
       -
       	allLabels, err := GetLabels(e, FilterIn("subject", pullAts))

     

       245
       245
       +
       	allLabels, err := GetLabels(e, orm.FilterIn("subject", pullAts))

     

       237
       246
        
       	if err != nil {

     

       238
       247
        
       		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       239
       248
        
       	}

     
···

       250
       259
        
       			sourceAts = append(sourceAts, *p.PullSource.RepoAt)

     

       251
       260
        
       		}

     

       252
       261
        
       	}

     

       253
       253
       -
       	sourceRepos, err := GetRepos(e, 0, FilterIn("at_uri", sourceAts))

     

       262
       262
       +
       	sourceRepos, err := GetRepos(e, 0, orm.FilterIn("at_uri", sourceAts))

     

       254
       263
        
       	if err != nil && !errors.Is(err, sql.ErrNoRows) {

     

       255
       264
        
       		return nil, fmt.Errorf("failed to get source repos: %w", err)

     

       256
       265
        
       	}

     
···

       266
       275
        
       		}

     

       267
       276
        
       	}

     

       268
       277
        
       

     

       278
       278
       +
       	allReferences, err := GetReferencesAll(e, orm.FilterIn("from_at", pullAts))

     

       279
       279
       +
       	if err != nil {

     

       280
       280
       +
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       281
       281
       +
       	}

     

       282
       282
       +
       	for pullAt, references := range allReferences {

     

       283
       283
       +
       		if pull, ok := pulls[pullAt]; ok {

     

       284
       284
       +
       			pull.References = references

     

       285
       285
       +
       		}

     

       286
       286
       +
       	}

     

       287
       287
       +
       

     

       269
       288
        
       	orderedByPullId := []*models.Pull{}

     

       270
       289
        
       	for _, p := range pulls {

     

       271
       290
        
       		orderedByPullId = append(orderedByPullId, p)

     
···

       277
       296
        
       	return orderedByPullId, nil

     

       278
       297
        
       }

     

       279
       298
        
       

     

       280
       280
       -
       func GetPulls(e Execer, filters ...filter) ([]*models.Pull, error) {

     

       299
       299
       +
       func GetPulls(e Execer, filters ...orm.Filter) ([]*models.Pull, error) {

     

       281
       300
        
       	return GetPullsWithLimit(e, 0, filters...)

     

       282
       301
        
       }

     

       283
       302
        
       

     

       303
       303
       +
       func GetPullIDs(e Execer, opts models.PullSearchOptions) ([]int64, error) {

     

       304
       304
       +
       	var ids []int64

     

       305
       305
       +
       

     

       306
       306
       +
       	var filters []orm.Filter

     

       307
       307
       +
       	filters = append(filters, orm.FilterEq("state", opts.State))

     

       308
       308
       +
       	if opts.RepoAt != "" {

     

       309
       309
       +
       		filters = append(filters, orm.FilterEq("repo_at", opts.RepoAt))

     

       310
       310
       +
       	}

     

       311
       311
       +
       

     

       312
       312
       +
       	var conditions []string

     

       313
       313
       +
       	var args []any

     

       314
       314
       +
       

     

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

     

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

     

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

     

       318
       318
       +
       	}

     

       319
       319
       +
       

     

       320
       320
       +
       	whereClause := ""

     

       321
       321
       +
       	if conditions != nil {

     

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

     

       323
       323
       +
       	}

     

       324
       324
       +
       	pageClause := ""

     

       325
       325
       +
       	if opts.Page.Limit != 0 {

     

       326
       326
       +
       		pageClause = fmt.Sprintf(

     

       327
       327
       +
       			" limit %d offset %d ",

     

       328
       328
       +
       			opts.Page.Limit,

     

       329
       329
       +
       			opts.Page.Offset,

     

       330
       330
       +
       		)

     

       331
       331
       +
       	}

     

       332
       332
       +
       

     

       333
       333
       +
       	query := fmt.Sprintf(

     

       334
       334
       +
       		`

     

       335
       335
       +
       		select

     

       336
       336
       +
       			id

     

       337
       337
       +
       		from

     

       338
       338
       +
       			pulls

     

       339
       339
       +
       		%s

     

       340
       340
       +
       		%s`,

     

       341
       341
       +
       		whereClause,

     

       342
       342
       +
       		pageClause,

     

       343
       343
       +
       	)

     

       344
       344
       +
       	args = append(args, opts.Page.Limit, opts.Page.Offset)

     

       345
       345
       +
       	rows, err := e.Query(query, args...)

     

       346
       346
       +
       	if err != nil {

     

       347
       347
       +
       		return nil, err

     

       348
       348
       +
       	}

     

       349
       349
       +
       	defer rows.Close()

     

       350
       350
       +
       

     

       351
       351
       +
       	for rows.Next() {

     

       352
       352
       +
       		var id int64

     

       353
       353
       +
       		err := rows.Scan(&id)

     

       354
       354
       +
       		if err != nil {

     

       355
       355
       +
       			return nil, err

     

       356
       356
       +
       		}

     

       357
       357
       +
       

     

       358
       358
       +
       		ids = append(ids, id)

     

       359
       359
       +
       	}

     

       360
       360
       +
       

     

       361
       361
       +
       	return ids, nil

     

       362
       362
       +
       }

     

       363
       363
       +
       

     

       284
       364
        
       func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*models.Pull, error) {

     

       285
       285
       -
       	pulls, err := GetPullsWithLimit(e, 1, FilterEq("repo_at", repoAt), FilterEq("pull_id", pullId))

     

       365
       365
       +
       	pulls, err := GetPullsWithLimit(e, 1, orm.FilterEq("repo_at", repoAt), orm.FilterEq("pull_id", pullId))

     

       286
       366
        
       	if err != nil {

     

       287
       367
        
       		return nil, err

     

       288
       368
        
       	}

     

       289
       289
       -
       	if pulls == nil {

     

       369
       369
       +
       	if len(pulls) == 0 {

     

       290
       370
        
       		return nil, sql.ErrNoRows

     

       291
       371
        
       	}

     

       292
       372
        
       

     
···

       294
       374
        
       }

     

       295
       375
        
       

     

       296
       376
        
       // mapping from pull -> pull submissions

     

       297
       297
       -
       func GetPullSubmissions(e Execer, filters ...filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       377
       377
       +
       func GetPullSubmissions(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]*models.PullSubmission, error) {

     

       298
       378
        
       	var conditions []string

     

       299
       379
        
       	var args []any

     

       300
       380
        
       	for _, filter := range filters {

     
···

       369
       449
        
       

     

       370
       450
        
       	// Get comments for all submissions using GetPullComments

     

       371
       451
        
       	submissionIds := slices.Collect(maps.Keys(submissionMap))

     

       372
       372
       -
       	comments, err := GetPullComments(e, FilterIn("submission_id", submissionIds))

     

       452
       452
       +
       	comments, err := GetPullComments(e, orm.FilterIn("submission_id", submissionIds))

     

       373
       453
        
       	if err != nil {

     

       374
       374
       -
       		return nil, err

     

       454
       454
       +
       		return nil, fmt.Errorf("failed to get pull comments: %w", err)

     

       375
       455
        
       	}

     

       376
       456
        
       	for _, comment := range comments {

     

       377
       457
        
       		if submission, ok := submissionMap[comment.SubmissionId]; ok {

     
···

       395
       475
        
       	return m, nil

     

       396
       476
        
       }

     

       397
       477
        
       

     

       398
       398
       -
       func GetPullComments(e Execer, filters ...filter) ([]models.PullComment, error) {

     

       478
       478
       +
       func GetPullComments(e Execer, filters ...orm.Filter) ([]models.PullComment, error) {

     

       399
       479
        
       	var conditions []string

     

       400
       480
        
       	var args []any

     

       401
       481
        
       	for _, filter := range filters {

     
···

       431
       511
        
       	}

     

       432
       512
        
       	defer rows.Close()

     

       433
       513
        
       

     

       434
       434
       -
       	var comments []models.PullComment

     

       514
       514
       +
       	commentMap := make(map[string]*models.PullComment)

     

       435
       515
        
       	for rows.Next() {

     

       436
       516
        
       		var comment models.PullComment

     

       437
       517
        
       		var createdAt string

     
···

       453
       533
        
       			comment.Created = t

     

       454
       534
        
       		}

     

       455
       535
        
       

     

       456
       456
       -
       		comments = append(comments, comment)

     

       536
       536
       +
       		atUri := comment.AtUri().String()

     

       537
       537
       +
       		commentMap[atUri] = &comment

     

       457
       538
        
       	}

     

       458
       539
        
       

     

       459
       540
        
       	if err := rows.Err(); err != nil {

     

       460
       541
        
       		return nil, err

     

       461
       542
        
       	}

     

       462
       543
        
       

     

       544
       544
       +
       	// collect references for each comments

     

       545
       545
       +
       	commentAts := slices.Collect(maps.Keys(commentMap))

     

       546
       546
       +
       	allReferencs, err := GetReferencesAll(e, orm.FilterIn("from_at", commentAts))

     

       547
       547
       +
       	if err != nil {

     

       548
       548
       +
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       549
       549
       +
       	}

     

       550
       550
       +
       	for commentAt, references := range allReferencs {

     

       551
       551
       +
       		if comment, ok := commentMap[commentAt.String()]; ok {

     

       552
       552
       +
       			comment.References = references

     

       553
       553
       +
       		}

     

       554
       554
       +
       	}

     

       555
       555
       +
       

     

       556
       556
       +
       	var comments []models.PullComment

     

       557
       557
       +
       	for _, c := range commentMap {

     

       558
       558
       +
       		comments = append(comments, *c)

     

       559
       559
       +
       	}

     

       560
       560
       +
       

     

       561
       561
       +
       	sort.Slice(comments, func(i, j int) bool {

     

       562
       562
       +
       		return comments[i].Created.Before(comments[j].Created)

     

       563
       563
       +
       	})

     

       564
       564
       +
       

     

       463
       565
        
       	return comments, nil

     

       464
       566
        
       }

     

       465
       567
        
       

     
···

       539
       641
        
       	return pulls, nil

     

       540
       642
        
       }

     

       541
       643
        
       

     

       542
       542
       -
       func NewPullComment(e Execer, comment *models.PullComment) (int64, error) {

     

       644
       644
       +
       func NewPullComment(tx *sql.Tx, comment *models.PullComment) (int64, error) {

     

       543
       645
        
       	query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)`

     

       544
       544
       -
       	res, err := e.Exec(

     

       646
       646
       +
       	res, err := tx.Exec(

     

       545
       647
        
       		query,

     

       546
       648
        
       		comment.OwnerDid,

     

       547
       649
        
       		comment.RepoAt,

     
···

       557
       659
        
       	i, err := res.LastInsertId()

     

       558
       660
        
       	if err != nil {

     

       559
       661
        
       		return 0, err

     

       662
       662
       +
       	}

     

       663
       663
       +
       

     

       664
       664
       +
       	if err := putReferences(tx, comment.AtUri(), comment.References); err != nil {

     

       665
       665
       +
       		return 0, fmt.Errorf("put reference_links: %w", err)

     

       560
       666
        
       	}

     

       561
       667
        
       

     

       562
       668
        
       	return i, nil

     
···

       603
       709
        
       	return err

     

       604
       710
        
       }

     

       605
       711
        
       

     

       606
       606
       -
       func SetPullParentChangeId(e Execer, parentChangeId string, filters ...filter) error {

     

       712
       712
       +
       func SetPullParentChangeId(e Execer, parentChangeId string, filters ...orm.Filter) error {

     

       607
       713
        
       	var conditions []string

     

       608
       714
        
       	var args []any

     

       609
       715
        
       

     
···

       627
       733
        
       

     

       628
       734
        
       // Only used when stacking to update contents in the event of a rebase (the interdiff should be empty).

     

       629
       735
        
       // otherwise submissions are immutable

     

       630
       630
       -
       func UpdatePull(e Execer, newPatch, sourceRev string, filters ...filter) error {

     

       736
       736
       +
       func UpdatePull(e Execer, newPatch, sourceRev string, filters ...orm.Filter) error {

     

       631
       737
        
       	var conditions []string

     

       632
       738
        
       	var args []any

     

       633
       739
        
       

     
···

       685
       791
        
       func GetStack(e Execer, stackId string) (models.Stack, error) {

     

       686
       792
        
       	unorderedPulls, err := GetPulls(

     

       687
       793
        
       		e,

     

       688
       688
       -
       		FilterEq("stack_id", stackId),

     

       689
       689
       -
       		FilterNotEq("state", models.PullDeleted),

     

       794
       794
       +
       		orm.FilterEq("stack_id", stackId),

     

       795
       795
       +
       		orm.FilterNotEq("state", models.PullDeleted),

     

       690
       796
        
       	)

     

       691
       797
        
       	if err != nil {

     

       692
       798
        
       		return nil, err

     
···

       730
       836
        
       func GetAbandonedPulls(e Execer, stackId string) ([]*models.Pull, error) {

     

       731
       837
        
       	pulls, err := GetPulls(

     

       732
       838
        
       		e,

     

       733
       733
       -
       		FilterEq("stack_id", stackId),

     

       734
       734
       -
       		FilterEq("state", models.PullDeleted),

     

       839
       839
       +
       		orm.FilterEq("stack_id", stackId),

     

       840
       840
       +
       		orm.FilterEq("state", models.PullDeleted),

     

       735
       841
        
       	)

     

       736
       842
        
       	if err != nil {

     

       737
       843
        
       		return nil, err

+2 -1

appview/db/punchcard.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       13
        
       // this adds to the existing count

     
···

       20
       21
        
       	return err

     

       21
       22
        
       }

     

       22
       23
        
       

     

       23
       23
       -
       func MakePunchcard(e Execer, filters ...filter) (*models.Punchcard, error) {

     

       24
       24
       +
       func MakePunchcard(e Execer, filters ...orm.Filter) (*models.Punchcard, error) {

     

       24
       25
        
       	punchcard := &models.Punchcard{}

     

       25
       26
        
       	now := time.Now()

     

       26
       27
        
       	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

+463

appview/db/reference.go

···

       1
       1
       +
       package db

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"database/sql"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"strings"

     

       7
       7
       +
       

     

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

     

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

     

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

     

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

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       // ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     

       15
       15
       +
       // It will ignore missing refLinks.

     

       16
       16
       +
       func ValidateReferenceLinks(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       17
       17
       +
       	var (

     

       18
       18
       +
       		issueRefs []models.ReferenceLink

     

       19
       19
       +
       		pullRefs  []models.ReferenceLink

     

       20
       20
       +
       	)

     

       21
       21
       +
       	for _, ref := range refLinks {

     

       22
       22
       +
       		switch ref.Kind {

     

       23
       23
       +
       		case models.RefKindIssue:

     

       24
       24
       +
       			issueRefs = append(issueRefs, ref)

     

       25
       25
       +
       		case models.RefKindPull:

     

       26
       26
       +
       			pullRefs = append(pullRefs, ref)

     

       27
       27
       +
       		}

     

       28
       28
       +
       	}

     

       29
       29
       +
       	issueUris, err := findIssueReferences(e, issueRefs)

     

       30
       30
       +
       	if err != nil {

     

       31
       31
       +
       		return nil, fmt.Errorf("find issue references: %w", err)

     

       32
       32
       +
       	}

     

       33
       33
       +
       	pullUris, err := findPullReferences(e, pullRefs)

     

       34
       34
       +
       	if err != nil {

     

       35
       35
       +
       		return nil, fmt.Errorf("find pull references: %w", err)

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	return append(issueUris, pullUris...), nil

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       func findIssueReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       42
       42
       +
       	if len(refLinks) == 0 {

     

       43
       43
       +
       		return nil, nil

     

       44
       44
       +
       	}

     

       45
       45
       +
       	vals := make([]string, len(refLinks))

     

       46
       46
       +
       	args := make([]any, 0, len(refLinks)*4)

     

       47
       47
       +
       	for i, ref := range refLinks {

     

       48
       48
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       49
       49
       +
       		args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId)

     

       50
       50
       +
       	}

     

       51
       51
       +
       	query := fmt.Sprintf(

     

       52
       52
       +
       		`with input(owner_did, name, issue_id, comment_id) as (

     

       53
       53
       +
       			values %s

     

       54
       54
       +
       		)

     

       55
       55
       +
       		select

     

       56
       56
       +
       			i.did, i.rkey,

     

       57
       57
       +
       			c.did, c.rkey

     

       58
       58
       +
       		from input inp

     

       59
       59
       +
       		join repos r

     

       60
       60
       +
       			on r.did = inp.owner_did

     

       61
       61
       +
       				and r.name = inp.name

     

       62
       62
       +
       		join issues i

     

       63
       63
       +
       			on i.repo_at = r.at_uri

     

       64
       64
       +
       				and i.issue_id = inp.issue_id

     

       65
       65
       +
       		left join issue_comments c

     

       66
       66
       +
       			on inp.comment_id is not null

     

       67
       67
       +
       				and c.issue_at = i.at_uri

     

       68
       68
       +
       				and c.id = inp.comment_id

     

       69
       69
       +
       		`,

     

       70
       70
       +
       		strings.Join(vals, ","),

     

       71
       71
       +
       	)

     

       72
       72
       +
       	rows, err := e.Query(query, args...)

     

       73
       73
       +
       	if err != nil {

     

       74
       74
       +
       		return nil, err

     

       75
       75
       +
       	}

     

       76
       76
       +
       	defer rows.Close()

     

       77
       77
       +
       

     

       78
       78
       +
       	var uris []syntax.ATURI

     

       79
       79
       +
       

     

       80
       80
       +
       	for rows.Next() {

     

       81
       81
       +
       		// Scan rows

     

       82
       82
       +
       		var issueOwner, issueRkey string

     

       83
       83
       +
       		var commentOwner, commentRkey sql.NullString

     

       84
       84
       +
       		var uri syntax.ATURI

     

       85
       85
       +
       		if err := rows.Scan(&issueOwner, &issueRkey, &commentOwner, &commentRkey); err != nil {

     

       86
       86
       +
       			return nil, err

     

       87
       87
       +
       		}

     

       88
       88
       +
       		if commentOwner.Valid && commentRkey.Valid {

     

       89
       89
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       90
       90
       +
       				"at://%s/%s/%s",

     

       91
       91
       +
       				commentOwner.String,

     

       92
       92
       +
       				tangled.RepoIssueCommentNSID,

     

       93
       93
       +
       				commentRkey.String,

     

       94
       94
       +
       			))

     

       95
       95
       +
       		} else {

     

       96
       96
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       97
       97
       +
       				"at://%s/%s/%s",

     

       98
       98
       +
       				issueOwner,

     

       99
       99
       +
       				tangled.RepoIssueNSID,

     

       100
       100
       +
       				issueRkey,

     

       101
       101
       +
       			))

     

       102
       102
       +
       		}

     

       103
       103
       +
       		uris = append(uris, uri)

     

       104
       104
       +
       	}

     

       105
       105
       +
       	if err := rows.Err(); err != nil {

     

       106
       106
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       107
       107
       +
       	}

     

       108
       108
       +
       

     

       109
       109
       +
       	return uris, nil

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       func findPullReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       113
       113
       +
       	if len(refLinks) == 0 {

     

       114
       114
       +
       		return nil, nil

     

       115
       115
       +
       	}

     

       116
       116
       +
       	vals := make([]string, len(refLinks))

     

       117
       117
       +
       	args := make([]any, 0, len(refLinks)*4)

     

       118
       118
       +
       	for i, ref := range refLinks {

     

       119
       119
       +
       		vals[i] = "(?, ?, ?, ?)"

     

       120
       120
       +
       		args = append(args, ref.Handle, ref.Repo, ref.SubjectId, ref.CommentId)

     

       121
       121
       +
       	}

     

       122
       122
       +
       	query := fmt.Sprintf(

     

       123
       123
       +
       		`with input(owner_did, name, pull_id, comment_id) as (

     

       124
       124
       +
       			values %s

     

       125
       125
       +
       		)

     

       126
       126
       +
       		select

     

       127
       127
       +
       			p.owner_did, p.rkey,

     

       128
       128
       +
       			c.comment_at

     

       129
       129
       +
       		from input inp

     

       130
       130
       +
       		join repos r

     

       131
       131
       +
       			on r.did = inp.owner_did

     

       132
       132
       +
       				and r.name = inp.name

     

       133
       133
       +
       		join pulls p

     

       134
       134
       +
       			on p.repo_at = r.at_uri

     

       135
       135
       +
       				and p.pull_id = inp.pull_id

     

       136
       136
       +
       		left join pull_comments c

     

       137
       137
       +
       			on inp.comment_id is not null

     

       138
       138
       +
       				and c.repo_at = r.at_uri and c.pull_id = p.pull_id

     

       139
       139
       +
       				and c.id = inp.comment_id

     

       140
       140
       +
       		`,

     

       141
       141
       +
       		strings.Join(vals, ","),

     

       142
       142
       +
       	)

     

       143
       143
       +
       	rows, err := e.Query(query, args...)

     

       144
       144
       +
       	if err != nil {

     

       145
       145
       +
       		return nil, err

     

       146
       146
       +
       	}

     

       147
       147
       +
       	defer rows.Close()

     

       148
       148
       +
       

     

       149
       149
       +
       	var uris []syntax.ATURI

     

       150
       150
       +
       

     

       151
       151
       +
       	for rows.Next() {

     

       152
       152
       +
       		// Scan rows

     

       153
       153
       +
       		var pullOwner, pullRkey string

     

       154
       154
       +
       		var commentUri sql.NullString

     

       155
       155
       +
       		var uri syntax.ATURI

     

       156
       156
       +
       		if err := rows.Scan(&pullOwner, &pullRkey, &commentUri); err != nil {

     

       157
       157
       +
       			return nil, err

     

       158
       158
       +
       		}

     

       159
       159
       +
       		if commentUri.Valid {

     

       160
       160
       +
       			// no-op

     

       161
       161
       +
       			uri = syntax.ATURI(commentUri.String)

     

       162
       162
       +
       		} else {

     

       163
       163
       +
       			uri = syntax.ATURI(fmt.Sprintf(

     

       164
       164
       +
       				"at://%s/%s/%s",

     

       165
       165
       +
       				pullOwner,

     

       166
       166
       +
       				tangled.RepoPullNSID,

     

       167
       167
       +
       				pullRkey,

     

       168
       168
       +
       			))

     

       169
       169
       +
       		}

     

       170
       170
       +
       		uris = append(uris, uri)

     

       171
       171
       +
       	}

     

       172
       172
       +
       	return uris, nil

     

       173
       173
       +
       }

     

       174
       174
       +
       

     

       175
       175
       +
       func putReferences(tx *sql.Tx, fromAt syntax.ATURI, references []syntax.ATURI) error {

     

       176
       176
       +
       	err := deleteReferences(tx, fromAt)

     

       177
       177
       +
       	if err != nil {

     

       178
       178
       +
       		return fmt.Errorf("delete old reference_links: %w", err)

     

       179
       179
       +
       	}

     

       180
       180
       +
       	if len(references) == 0 {

     

       181
       181
       +
       		return nil

     

       182
       182
       +
       	}

     

       183
       183
       +
       

     

       184
       184
       +
       	values := make([]string, 0, len(references))

     

       185
       185
       +
       	args := make([]any, 0, len(references)*2)

     

       186
       186
       +
       	for _, ref := range references {

     

       187
       187
       +
       		values = append(values, "(?, ?)")

     

       188
       188
       +
       		args = append(args, fromAt, ref)

     

       189
       189
       +
       	}

     

       190
       190
       +
       	_, err = tx.Exec(

     

       191
       191
       +
       		fmt.Sprintf(

     

       192
       192
       +
       			`insert into reference_links (from_at, to_at)

     

       193
       193
       +
       			values %s`,

     

       194
       194
       +
       			strings.Join(values, ","),

     

       195
       195
       +
       		),

     

       196
       196
       +
       		args...,

     

       197
       197
       +
       	)

     

       198
       198
       +
       	if err != nil {

     

       199
       199
       +
       		return fmt.Errorf("insert new reference_links: %w", err)

     

       200
       200
       +
       	}

     

       201
       201
       +
       	return nil

     

       202
       202
       +
       }

     

       203
       203
       +
       

     

       204
       204
       +
       func deleteReferences(tx *sql.Tx, fromAt syntax.ATURI) error {

     

       205
       205
       +
       	_, err := tx.Exec(`delete from reference_links where from_at = ?`, fromAt)

     

       206
       206
       +
       	return err

     

       207
       207
       +
       }

     

       208
       208
       +
       

     

       209
       209
       +
       func GetReferencesAll(e Execer, filters ...orm.Filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       210
       210
       +
       	var (

     

       211
       211
       +
       		conditions []string

     

       212
       212
       +
       		args       []any

     

       213
       213
       +
       	)

     

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

     

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

     

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

     

       217
       217
       +
       	}

     

       218
       218
       +
       

     

       219
       219
       +
       	whereClause := ""

     

       220
       220
       +
       	if conditions != nil {

     

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

     

       222
       222
       +
       	}

     

       223
       223
       +
       

     

       224
       224
       +
       	rows, err := e.Query(

     

       225
       225
       +
       		fmt.Sprintf(

     

       226
       226
       +
       			`select from_at, to_at from reference_links %s`,

     

       227
       227
       +
       			whereClause,

     

       228
       228
       +
       		),

     

       229
       229
       +
       		args...,

     

       230
       230
       +
       	)

     

       231
       231
       +
       	if err != nil {

     

       232
       232
       +
       		return nil, fmt.Errorf("query reference_links: %w", err)

     

       233
       233
       +
       	}

     

       234
       234
       +
       	defer rows.Close()

     

       235
       235
       +
       

     

       236
       236
       +
       	result := make(map[syntax.ATURI][]syntax.ATURI)

     

       237
       237
       +
       

     

       238
       238
       +
       	for rows.Next() {

     

       239
       239
       +
       		var from, to syntax.ATURI

     

       240
       240
       +
       		if err := rows.Scan(&from, &to); err != nil {

     

       241
       241
       +
       			return nil, fmt.Errorf("scan row: %w", err)

     

       242
       242
       +
       		}

     

       243
       243
       +
       

     

       244
       244
       +
       		result[from] = append(result[from], to)

     

       245
       245
       +
       	}

     

       246
       246
       +
       	if err := rows.Err(); err != nil {

     

       247
       247
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       248
       248
       +
       	}

     

       249
       249
       +
       

     

       250
       250
       +
       	return result, nil

     

       251
       251
       +
       }

     

       252
       252
       +
       

     

       253
       253
       +
       func GetBacklinks(e Execer, target syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       254
       254
       +
       	rows, err := e.Query(

     

       255
       255
       +
       		`select from_at from reference_links

     

       256
       256
       +
       		where to_at = ?`,

     

       257
       257
       +
       		target,

     

       258
       258
       +
       	)

     

       259
       259
       +
       	if err != nil {

     

       260
       260
       +
       		return nil, fmt.Errorf("query backlinks: %w", err)

     

       261
       261
       +
       	}

     

       262
       262
       +
       	defer rows.Close()

     

       263
       263
       +
       

     

       264
       264
       +
       	var (

     

       265
       265
       +
       		backlinks    []models.RichReferenceLink

     

       266
       266
       +
       		backlinksMap = make(map[string][]syntax.ATURI)

     

       267
       267
       +
       	)

     

       268
       268
       +
       	for rows.Next() {

     

       269
       269
       +
       		var from syntax.ATURI

     

       270
       270
       +
       		if err := rows.Scan(&from); err != nil {

     

       271
       271
       +
       			return nil, fmt.Errorf("scan row: %w", err)

     

       272
       272
       +
       		}

     

       273
       273
       +
       		nsid := from.Collection().String()

     

       274
       274
       +
       		backlinksMap[nsid] = append(backlinksMap[nsid], from)

     

       275
       275
       +
       	}

     

       276
       276
       +
       	if err := rows.Err(); err != nil {

     

       277
       277
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       278
       278
       +
       	}

     

       279
       279
       +
       

     

       280
       280
       +
       	var ls []models.RichReferenceLink

     

       281
       281
       +
       	ls, err = getIssueBacklinks(e, backlinksMap[tangled.RepoIssueNSID])

     

       282
       282
       +
       	if err != nil {

     

       283
       283
       +
       		return nil, fmt.Errorf("get issue backlinks: %w", err)

     

       284
       284
       +
       	}

     

       285
       285
       +
       	backlinks = append(backlinks, ls...)

     

       286
       286
       +
       	ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.RepoIssueCommentNSID])

     

       287
       287
       +
       	if err != nil {

     

       288
       288
       +
       		return nil, fmt.Errorf("get issue_comment backlinks: %w", err)

     

       289
       289
       +
       	}

     

       290
       290
       +
       	backlinks = append(backlinks, ls...)

     

       291
       291
       +
       	ls, err = getPullBacklinks(e, backlinksMap[tangled.RepoPullNSID])

     

       292
       292
       +
       	if err != nil {

     

       293
       293
       +
       		return nil, fmt.Errorf("get pull backlinks: %w", err)

     

       294
       294
       +
       	}

     

       295
       295
       +
       	backlinks = append(backlinks, ls...)

     

       296
       296
       +
       	ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.RepoPullCommentNSID])

     

       297
       297
       +
       	if err != nil {

     

       298
       298
       +
       		return nil, fmt.Errorf("get pull_comment backlinks: %w", err)

     

       299
       299
       +
       	}

     

       300
       300
       +
       	backlinks = append(backlinks, ls...)

     

       301
       301
       +
       

     

       302
       302
       +
       	return backlinks, nil

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

       305
       305
       +
       func getIssueBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       306
       306
       +
       	if len(aturis) == 0 {

     

       307
       307
       +
       		return nil, nil

     

       308
       308
       +
       	}

     

       309
       309
       +
       	vals := make([]string, len(aturis))

     

       310
       310
       +
       	args := make([]any, 0, len(aturis)*2)

     

       311
       311
       +
       	for i, aturi := range aturis {

     

       312
       312
       +
       		vals[i] = "(?, ?)"

     

       313
       313
       +
       		did := aturi.Authority().String()

     

       314
       314
       +
       		rkey := aturi.RecordKey().String()

     

       315
       315
       +
       		args = append(args, did, rkey)

     

       316
       316
       +
       	}

     

       317
       317
       +
       	rows, err := e.Query(

     

       318
       318
       +
       		fmt.Sprintf(

     

       319
       319
       +
       			`select r.did, r.name, i.issue_id, i.title, i.open

     

       320
       320
       +
       			from issues i

     

       321
       321
       +
       			join repos r

     

       322
       322
       +
       				on r.at_uri = i.repo_at

     

       323
       323
       +
       			where (i.did, i.rkey) in (%s)`,

     

       324
       324
       +
       			strings.Join(vals, ","),

     

       325
       325
       +
       		),

     

       326
       326
       +
       		args...,

     

       327
       327
       +
       	)

     

       328
       328
       +
       	if err != nil {

     

       329
       329
       +
       		return nil, err

     

       330
       330
       +
       	}

     

       331
       331
       +
       	defer rows.Close()

     

       332
       332
       +
       	var refLinks []models.RichReferenceLink

     

       333
       333
       +
       	for rows.Next() {

     

       334
       334
       +
       		var l models.RichReferenceLink

     

       335
       335
       +
       		l.Kind = models.RefKindIssue

     

       336
       336
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       337
       337
       +
       			return nil, err

     

       338
       338
       +
       		}

     

       339
       339
       +
       		refLinks = append(refLinks, l)

     

       340
       340
       +
       	}

     

       341
       341
       +
       	if err := rows.Err(); err != nil {

     

       342
       342
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       343
       343
       +
       	}

     

       344
       344
       +
       	return refLinks, nil

     

       345
       345
       +
       }

     

       346
       346
       +
       

     

       347
       347
       +
       func getIssueCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       348
       348
       +
       	if len(aturis) == 0 {

     

       349
       349
       +
       		return nil, nil

     

       350
       350
       +
       	}

     

       351
       351
       +
       	filter := orm.FilterIn("c.at_uri", aturis)

     

       352
       352
       +
       	rows, err := e.Query(

     

       353
       353
       +
       		fmt.Sprintf(

     

       354
       354
       +
       			`select r.did, r.name, i.issue_id, c.id, i.title, i.open

     

       355
       355
       +
       			from issue_comments c

     

       356
       356
       +
       			join issues i

     

       357
       357
       +
       				on i.at_uri = c.issue_at

     

       358
       358
       +
       			join repos r

     

       359
       359
       +
       				on r.at_uri = i.repo_at

     

       360
       360
       +
       			where %s`,

     

       361
       361
       +
       			filter.Condition(),

     

       362
       362
       +
       		),

     

       363
       363
       +
       		filter.Arg()...,

     

       364
       364
       +
       	)

     

       365
       365
       +
       	if err != nil {

     

       366
       366
       +
       		return nil, err

     

       367
       367
       +
       	}

     

       368
       368
       +
       	defer rows.Close()

     

       369
       369
       +
       	var refLinks []models.RichReferenceLink

     

       370
       370
       +
       	for rows.Next() {

     

       371
       371
       +
       		var l models.RichReferenceLink

     

       372
       372
       +
       		l.Kind = models.RefKindIssue

     

       373
       373
       +
       		l.CommentId = new(int)

     

       374
       374
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       375
       375
       +
       			return nil, err

     

       376
       376
       +
       		}

     

       377
       377
       +
       		refLinks = append(refLinks, l)

     

       378
       378
       +
       	}

     

       379
       379
       +
       	if err := rows.Err(); err != nil {

     

       380
       380
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       381
       381
       +
       	}

     

       382
       382
       +
       	return refLinks, nil

     

       383
       383
       +
       }

     

       384
       384
       +
       

     

       385
       385
       +
       func getPullBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       386
       386
       +
       	if len(aturis) == 0 {

     

       387
       387
       +
       		return nil, nil

     

       388
       388
       +
       	}

     

       389
       389
       +
       	vals := make([]string, len(aturis))

     

       390
       390
       +
       	args := make([]any, 0, len(aturis)*2)

     

       391
       391
       +
       	for i, aturi := range aturis {

     

       392
       392
       +
       		vals[i] = "(?, ?)"

     

       393
       393
       +
       		did := aturi.Authority().String()

     

       394
       394
       +
       		rkey := aturi.RecordKey().String()

     

       395
       395
       +
       		args = append(args, did, rkey)

     

       396
       396
       +
       	}

     

       397
       397
       +
       	rows, err := e.Query(

     

       398
       398
       +
       		fmt.Sprintf(

     

       399
       399
       +
       			`select r.did, r.name, p.pull_id, p.title, p.state

     

       400
       400
       +
       			from pulls p

     

       401
       401
       +
       			join repos r

     

       402
       402
       +
       				on r.at_uri = p.repo_at

     

       403
       403
       +
       			where (p.owner_did, p.rkey) in (%s)`,

     

       404
       404
       +
       			strings.Join(vals, ","),

     

       405
       405
       +
       		),

     

       406
       406
       +
       		args...,

     

       407
       407
       +
       	)

     

       408
       408
       +
       	if err != nil {

     

       409
       409
       +
       		return nil, err

     

       410
       410
       +
       	}

     

       411
       411
       +
       	defer rows.Close()

     

       412
       412
       +
       	var refLinks []models.RichReferenceLink

     

       413
       413
       +
       	for rows.Next() {

     

       414
       414
       +
       		var l models.RichReferenceLink

     

       415
       415
       +
       		l.Kind = models.RefKindPull

     

       416
       416
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       417
       417
       +
       			return nil, err

     

       418
       418
       +
       		}

     

       419
       419
       +
       		refLinks = append(refLinks, l)

     

       420
       420
       +
       	}

     

       421
       421
       +
       	if err := rows.Err(); err != nil {

     

       422
       422
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       423
       423
       +
       	}

     

       424
       424
       +
       	return refLinks, nil

     

       425
       425
       +
       }

     

       426
       426
       +
       

     

       427
       427
       +
       func getPullCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       428
       428
       +
       	if len(aturis) == 0 {

     

       429
       429
       +
       		return nil, nil

     

       430
       430
       +
       	}

     

       431
       431
       +
       	filter := orm.FilterIn("c.comment_at", aturis)

     

       432
       432
       +
       	rows, err := e.Query(

     

       433
       433
       +
       		fmt.Sprintf(

     

       434
       434
       +
       			`select r.did, r.name, p.pull_id, c.id, p.title, p.state

     

       435
       435
       +
       			from repos r

     

       436
       436
       +
       			join pulls p

     

       437
       437
       +
       				on r.at_uri = p.repo_at

     

       438
       438
       +
       			join pull_comments c

     

       439
       439
       +
       				on r.at_uri = c.repo_at and p.pull_id = c.pull_id

     

       440
       440
       +
       			where %s`,

     

       441
       441
       +
       			filter.Condition(),

     

       442
       442
       +
       		),

     

       443
       443
       +
       		filter.Arg()...,

     

       444
       444
       +
       	)

     

       445
       445
       +
       	if err != nil {

     

       446
       446
       +
       		return nil, err

     

       447
       447
       +
       	}

     

       448
       448
       +
       	defer rows.Close()

     

       449
       449
       +
       	var refLinks []models.RichReferenceLink

     

       450
       450
       +
       	for rows.Next() {

     

       451
       451
       +
       		var l models.RichReferenceLink

     

       452
       452
       +
       		l.Kind = models.RefKindPull

     

       453
       453
       +
       		l.CommentId = new(int)

     

       454
       454
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       455
       455
       +
       			return nil, err

     

       456
       456
       +
       		}

     

       457
       457
       +
       		refLinks = append(refLinks, l)

     

       458
       458
       +
       	}

     

       459
       459
       +
       	if err := rows.Err(); err != nil {

     

       460
       460
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       461
       461
       +
       	}

     

       462
       462
       +
       	return refLinks, nil

     

       463
       463
       +
       }

+4 -3

appview/db/registration.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetRegistrations(e Execer, filters ...filter) ([]models.Registration, error) {

     

       13
       13
       +
       func GetRegistrations(e Execer, filters ...orm.Filter) ([]models.Registration, error) {

     

       13
       14
        
       	var registrations []models.Registration

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       69
       70
        
       	return registrations, nil

     

       70
       71
        
       }

     

       71
       72
        
       

     

       72
       72
       -
       func MarkRegistered(e Execer, filters ...filter) error {

     

       73
       73
       +
       func MarkRegistered(e Execer, filters ...orm.Filter) error {

     

       73
       74
        
       	var conditions []string

     

       74
       75
        
       	var args []any

     

       75
       76
        
       	for _, filter := range filters {

     
···

       94
       95
        
       	return err

     

       95
       96
        
       }

     

       96
       97
        
       

     

       97
       97
       -
       func DeleteKnot(e Execer, filters ...filter) error {

     

       98
       98
       +
       func DeleteKnot(e Execer, filters ...orm.Filter) error {

     

       98
       99
        
       	var conditions []string

     

       99
       100
        
       	var args []any

     

       100
       101
        
       	for _, filter := range filters {

+70 -48

appview/db/repos.go

···

       10
       10
        
       	"time"

     

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
       14
       -
       	"tangled.org/core/api/tangled"

     

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

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       16
       15
        
       )

     

       17
       16
        
       

     

       18
       18
       -
       type Repo struct {

     

       19
       19
       -
       	Id          int64

     

       20
       20
       -
       	Did         string

     

       21
       21
       -
       	Name        string

     

       22
       22
       -
       	Knot        string

     

       23
       23
       -
       	Rkey        string

     

       24
       24
       -
       	Created     time.Time

     

       25
       25
       -
       	Description string

     

       26
       26
       -
       	Spindle     string

     

       27
       27
       -
       

     

       28
       28
       -
       	// optionally, populate this when querying for reverse mappings

     

       29
       29
       -
       	RepoStats *models.RepoStats

     

       30
       30
       -
       

     

       31
       31
       -
       	// optional

     

       32
       32
       -
       	Source string

     

       33
       33
       -
       }

     

       34
       34
       -
       

     

       35
       35
       -
       func (r Repo) RepoAt() syntax.ATURI {

     

       36
       36
       -
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))

     

       37
       37
       -
       }

     

       38
       38
       -
       

     

       39
       39
       -
       func (r Repo) DidSlashRepo() string {

     

       40
       40
       -
       	p, _ := securejoin.SecureJoin(r.Did, r.Name)

     

       41
       41
       -
       	return p

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {

     

       17
       17
       +
       func GetRepos(e Execer, limit int, filters ...orm.Filter) ([]models.Repo, error) {

     

       45
       18
        
       	repoMap := make(map[syntax.ATURI]*models.Repo)

     

       46
       19
        
       

     

       47
       20
        
       	var conditions []string

     
···

       70
       43
        
       			rkey,

     

       71
       44
        
       			created,

     

       72
       45
        
       			description,

     

       46
       46
       +
       			website,

     

       47
       47
       +
       			topics,

     

       73
       48
        
       			source,

     

       74
       49
        
       			spindle

     

       75
       50
        
       		from

     
···

       89
       64
        
       	for rows.Next() {

     

       90
       65
        
       		var repo models.Repo

     

       91
       66
        
       		var createdAt string

     

       92
       92
       -
       		var description, source, spindle sql.NullString

     

       67
       67
       +
       		var description, website, topicStr, source, spindle sql.NullString

     

       93
       68
        
       

     

       94
       69
        
       		err := rows.Scan(

     

       95
       70
        
       			&repo.Id,

     
···

       99
       74
        
       			&repo.Rkey,

     

       100
       75
        
       			&createdAt,

     

       101
       76
        
       			&description,

     

       77
       77
       +
       			&website,

     

       78
       78
       +
       			&topicStr,

     

       102
       79
        
       			&source,

     

       103
       80
        
       			&spindle,

     

       104
       81
        
       		)

     
···

       111
       88
        
       		}

     

       112
       89
        
       		if description.Valid {

     

       113
       90
        
       			repo.Description = description.String

     

       91
       91
       +
       		}

     

       92
       92
       +
       		if website.Valid {

     

       93
       93
       +
       			repo.Website = website.String

     

       94
       94
       +
       		}

     

       95
       95
       +
       		if topicStr.Valid {

     

       96
       96
       +
       			repo.Topics = strings.Fields(topicStr.String)

     

       114
       97
        
       		}

     

       115
       98
        
       		if source.Valid {

     

       116
       99
        
       			repo.Source = source.String

     
···

       198
       181
        
       

     

       199
       182
        
       	starCountQuery := fmt.Sprintf(

     

       200
       183
        
       		`select

     

       201
       201
       -
       			repo_at, count(1)

     

       184
       184
       +
       			subject_at, count(1)

     

       202
       185
        
       		from stars

     

       203
       203
       -
       		where repo_at in (%s)

     

       204
       204
       -
       		group by repo_at`,

     

       186
       186
       +
       		where subject_at in (%s)

     

       187
       187
       +
       		group by subject_at`,

     

       205
       188
        
       		inClause,

     

       206
       189
        
       	)

     

       207
       190
        
       	rows, err = e.Query(starCountQuery, args...)

     
···

       312
       295
        
       }

     

       313
       296
        
       

     

       314
       297
        
       // helper to get exactly one repo

     

       315
       315
       -
       func GetRepo(e Execer, filters ...filter) (*models.Repo, error) {

     

       298
       298
       +
       func GetRepo(e Execer, filters ...orm.Filter) (*models.Repo, error) {

     

       316
       299
        
       	repos, err := GetRepos(e, 0, filters...)

     

       317
       300
        
       	if err != nil {

     

       318
       301
        
       		return nil, err

     
···

       329
       312
        
       	return &repos[0], nil

     

       330
       313
        
       }

     

       331
       314
        
       

     

       332
       332
       -
       func CountRepos(e Execer, filters ...filter) (int64, error) {

     

       315
       315
       +
       func CountRepos(e Execer, filters ...orm.Filter) (int64, error) {

     

       333
       316
        
       	var conditions []string

     

       334
       317
        
       	var args []any

     

       335
       318
        
       	for _, filter := range filters {

     
···

       356
       339
        
       func GetRepoByAtUri(e Execer, atUri string) (*models.Repo, error) {

     

       357
       340
        
       	var repo models.Repo

     

       358
       341
        
       	var nullableDescription sql.NullString

     

       342
       342
       +
       	var nullableWebsite sql.NullString

     

       343
       343
       +
       	var nullableTopicStr sql.NullString

     

       359
       344
        
       

     

       360
       360
       -
       	row := e.QueryRow(`select id, did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri)

     

       345
       345
       +
       	row := e.QueryRow(`select id, did, name, knot, created, rkey, description, website, topics from repos where at_uri = ?`, atUri)

     

       361
       346
        
       

     

       362
       347
        
       	var createdAt string

     

       363
       363
       -
       	if err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription); err != nil {

     

       348
       348
       +
       	if err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription, &nullableWebsite, &nullableTopicStr); err != nil {

     

       364
       349
        
       		return nil, err

     

       365
       350
        
       	}

     

       366
       351
        
       	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     
···

       368
       353
        
       

     

       369
       354
        
       	if nullableDescription.Valid {

     

       370
       355
        
       		repo.Description = nullableDescription.String

     

       371
       371
       -
       	} else {

     

       372
       372
       -
       		repo.Description = ""

     

       356
       356
       +
       	}

     

       357
       357
       +
       	if nullableWebsite.Valid {

     

       358
       358
       +
       		repo.Website = nullableWebsite.String

     

       359
       359
       +
       	}

     

       360
       360
       +
       	if nullableTopicStr.Valid {

     

       361
       361
       +
       		repo.Topics = strings.Fields(nullableTopicStr.String)

     

       373
       362
        
       	}

     

       374
       363
        
       

     

       375
       364
        
       	return &repo, nil

     

       376
       365
        
       }

     

       377
       366
        
       

     

       367
       367
       +
       func PutRepo(tx *sql.Tx, repo models.Repo) error {

     

       368
       368
       +
       	_, err := tx.Exec(

     

       369
       369
       +
       		`update repos

     

       370
       370
       +
       		set knot = ?, description = ?, website = ?, topics = ?

     

       371
       371
       +
       		where did = ? and rkey = ?

     

       372
       372
       +
       		`,

     

       373
       373
       +
       		repo.Knot, repo.Description, repo.Website, repo.TopicStr(), repo.Did, repo.Rkey,

     

       374
       374
       +
       	)

     

       375
       375
       +
       	return err

     

       376
       376
       +
       }

     

       377
       377
       +
       

     

       378
       378
        
       func AddRepo(tx *sql.Tx, repo *models.Repo) error {

     

       379
       379
        
       	_, err := tx.Exec(

     

       380
       380
        
       		`insert into repos

     

       381
       381
       -
       		(did, name, knot, rkey, at_uri, description, source)

     

       382
       382
       -
       		values (?, ?, ?, ?, ?, ?, ?)`,

     

       383
       383
       -
       		repo.Did, repo.Name, repo.Knot, repo.Rkey, repo.RepoAt().String(), repo.Description, repo.Source,

     

       381
       381
       +
       		(did, name, knot, rkey, at_uri, description, website, topics, source)

     

       382
       382
       +
       		values (?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       383
       383
       +
       		repo.Did, repo.Name, repo.Knot, repo.Rkey, repo.RepoAt().String(), repo.Description, repo.Website, repo.TopicStr(), repo.Source,

     

       384
       384
        
       	)

     

       385
       385
        
       	if err != nil {

     

       386
       386
        
       		return fmt.Errorf("failed to insert repo: %w", err)

     
···

       412
       412
        
       	return nullableSource.String, nil

     

       413
       413
        
       }

     

       414
       414
        
       

     

       415
       415
       +
       func GetRepoSourceRepo(e Execer, repoAt syntax.ATURI) (*models.Repo, error) {

     

       416
       416
       +
       	source, err := GetRepoSource(e, repoAt)

     

       417
       417
       +
       	if source == "" || errors.Is(err, sql.ErrNoRows) {

     

       418
       418
       +
       		return nil, nil

     

       419
       419
       +
       	}

     

       420
       420
       +
       	if err != nil {

     

       421
       421
       +
       		return nil, err

     

       422
       422
       +
       	}

     

       423
       423
       +
       	return GetRepoByAtUri(e, source)

     

       424
       424
       +
       }

     

       425
       425
       +
       

     

       415
       426
        
       func GetForksByDid(e Execer, did string) ([]models.Repo, error) {

     

       416
       427
        
       	var repos []models.Repo

     

       417
       428
        
       

     

       418
       429
        
       	rows, err := e.Query(

     

       419
       419
       -
       		`select distinct r.id, r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source

     

       430
       430
       +
       		`select distinct r.id, r.did, r.name, r.knot, r.rkey, r.description, r.website, r.created, r.source

     

       420
       431
        
       		from repos r

     

       421
       432
        
       		left join collaborators c on r.at_uri = c.repo_at

     

       422
       433
        
       		where (r.did = ? or c.subject_did = ?)

     
···

       434
       445
        
       		var repo models.Repo

     

       435
       446
        
       		var createdAt string

     

       436
       447
        
       		var nullableDescription sql.NullString

     

       448
       448
       +
       		var nullableWebsite sql.NullString

     

       437
       449
        
       		var nullableSource sql.NullString

     

       438
       450
        
       

     

       439
       439
       -
       		err := rows.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       451
       451
       +
       		err := rows.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &nullableWebsite, &createdAt, &nullableSource)

     

       440
       452
        
       		if err != nil {

     

       441
       453
        
       			return nil, err

     

       442
       454
        
       		}

     
···

       470
       482
        
       	var repo models.Repo

     

       471
       483
        
       	var createdAt string

     

       472
       484
        
       	var nullableDescription sql.NullString

     

       485
       485
       +
       	var nullableWebsite sql.NullString

     

       486
       486
       +
       	var nullableTopicStr sql.NullString

     

       473
       487
        
       	var nullableSource sql.NullString

     

       474
       488
        
       

     

       475
       489
        
       	row := e.QueryRow(

     

       476
       476
       -
       		`select id, did, name, knot, rkey, description, created, source

     

       490
       490
       +
       		`select id, did, name, knot, rkey, description, website, topics, created, source

     

       477
       491
        
       		from repos

     

       478
       492
        
       		where did = ? and name = ? and source is not null and source != ''`,

     

       479
       493
        
       		did, name,

     

       480
       494
        
       	)

     

       481
       495
        
       

     

       482
       482
       -
       	err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       496
       496
       +
       	err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &nullableWebsite, &nullableTopicStr, &createdAt, &nullableSource)

     

       483
       497
        
       	if err != nil {

     

       484
       498
        
       		return nil, err

     

       485
       499
        
       	}

     

       486
       500
        
       

     

       487
       501
        
       	if nullableDescription.Valid {

     

       488
       502
        
       		repo.Description = nullableDescription.String

     

       503
       503
       +
       	}

     

       504
       504
       +
       

     

       505
       505
       +
       	if nullableWebsite.Valid {

     

       506
       506
       +
       		repo.Website = nullableWebsite.String

     

       507
       507
       +
       	}

     

       508
       508
       +
       

     

       509
       509
       +
       	if nullableTopicStr.Valid {

     

       510
       510
       +
       		repo.Topics = strings.Fields(nullableTopicStr.String)

     

       489
       511
        
       	}

     

       490
       512
        
       

     

       491
       513
        
       	if nullableSource.Valid {

     
···

       521
       543
        
       	return err

     

       522
       544
        
       }

     

       523
       545
        
       

     

       524
       524
       -
       func UnsubscribeLabel(e Execer, filters ...filter) error {

     

       546
       546
       +
       func UnsubscribeLabel(e Execer, filters ...orm.Filter) error {

     

       525
       547
        
       	var conditions []string

     

       526
       548
        
       	var args []any

     

       527
       549
        
       	for _, filter := range filters {

     
···

       539
       561
        
       	return err

     

       540
       562
        
       }

     

       541
       563
        
       

     

       542
       542
       -
       func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) {

     

       564
       564
       +
       func GetRepoLabels(e Execer, filters ...orm.Filter) ([]models.RepoLabel, error) {

     

       543
       565
        
       	var conditions []string

     

       544
       566
        
       	var args []any

     

       545
       567
        
       	for _, filter := range filters {

+6 -5

appview/db/spindle.go

···

       7
       7
        
       	"time"

     

       8
       8
        
       

     

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

     

       10
       10
       +
       	"tangled.org/core/orm"

     

       10
       11
        
       )

     

       11
       12
        
       

     

       12
       12
       -
       func GetSpindles(e Execer, filters ...filter) ([]models.Spindle, error) {

     

       13
       13
       +
       func GetSpindles(e Execer, filters ...orm.Filter) ([]models.Spindle, error) {

     

       13
       14
        
       	var spindles []models.Spindle

     

       14
       15
        
       

     

       15
       16
        
       	var conditions []string

     
···

       91
       92
        
       	return err

     

       92
       93
        
       }

     

       93
       94
        
       

     

       94
       94
       -
       func VerifySpindle(e Execer, filters ...filter) (int64, error) {

     

       95
       95
       +
       func VerifySpindle(e Execer, filters ...orm.Filter) (int64, error) {

     

       95
       96
        
       	var conditions []string

     

       96
       97
        
       	var args []any

     

       97
       98
        
       	for _, filter := range filters {

     
···

       114
       115
        
       	return res.RowsAffected()

     

       115
       116
        
       }

     

       116
       117
        
       

     

       117
       117
       -
       func DeleteSpindle(e Execer, filters ...filter) error {

     

       118
       118
       +
       func DeleteSpindle(e Execer, filters ...orm.Filter) error {

     

       118
       119
        
       	var conditions []string

     

       119
       120
        
       	var args []any

     

       120
       121
        
       	for _, filter := range filters {

     
···

       144
       145
        
       	return err

     

       145
       146
        
       }

     

       146
       147
        
       

     

       147
       147
       -
       func RemoveSpindleMember(e Execer, filters ...filter) error {

     

       148
       148
       +
       func RemoveSpindleMember(e Execer, filters ...orm.Filter) error {

     

       148
       149
        
       	var conditions []string

     

       149
       150
        
       	var args []any

     

       150
       151
        
       	for _, filter := range filters {

     
···

       163
       164
        
       	return err

     

       164
       165
        
       }

     

       165
       166
        
       

     

       166
       166
       -
       func GetSpindleMembers(e Execer, filters ...filter) ([]models.SpindleMember, error) {

     

       167
       167
       +
       func GetSpindleMembers(e Execer, filters ...orm.Filter) ([]models.SpindleMember, error) {

     

       167
       168
        
       	var members []models.SpindleMember

     

       168
       169
        
       

     

       169
       170
        
       	var conditions []string

+43 -102

appview/db/star.go

···

       11
       11
        
       

     

       12
       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       13
        
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       func AddStar(e Execer, star *models.Star) error {

     

       17
       17
       -
       	query := `insert or ignore into stars (starred_by_did, repo_at, rkey) values (?, ?, ?)`

     

       18
       18
       +
       	query := `insert or ignore into stars (did, subject_at, rkey) values (?, ?, ?)`

     

       18
       19
        
       	_, err := e.Exec(

     

       19
       20
        
       		query,

     

       20
       20
       -
       		star.StarredByDid,

     

       21
       21
       +
       		star.Did,

     

       21
       22
        
       		star.RepoAt.String(),

     

       22
       23
        
       		star.Rkey,

     

       23
       24
        
       	)

     
···

       25
       26
        
       }

     

       26
       27
        
       

     

       27
       28
        
       // Get a star record

     

       28
       28
       -
       func GetStar(e Execer, starredByDid string, repoAt syntax.ATURI) (*models.Star, error) {

     

       29
       29
       +
       func GetStar(e Execer, did string, subjectAt syntax.ATURI) (*models.Star, error) {

     

       29
       30
        
       	query := `

     

       30
       30
       -
       	select starred_by_did, repo_at, created, rkey

     

       31
       31
       +
       	select did, subject_at, created, rkey

     

       31
       32
        
       	from stars

     

       32
       32
       -
       	where starred_by_did = ? and repo_at = ?`

     

       33
       33
       -
       	row := e.QueryRow(query, starredByDid, repoAt)

     

       33
       33
       +
       	where did = ? and subject_at = ?`

     

       34
       34
       +
       	row := e.QueryRow(query, did, subjectAt)

     

       34
       35
        
       

     

       35
       36
        
       	var star models.Star

     

       36
       37
        
       	var created string

     

       37
       37
       -
       	err := row.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)

     

       38
       38
       +
       	err := row.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)

     

       38
       39
        
       	if err != nil {

     

       39
       40
        
       		return nil, err

     

       40
       41
        
       	}

     
···

       51
       52
        
       }

     

       52
       53
        
       

     

       53
       54
        
       // Remove a star

     

       54
       54
       -
       func DeleteStar(e Execer, starredByDid string, repoAt syntax.ATURI) error {

     

       55
       55
       -
       	_, err := e.Exec(`delete from stars where starred_by_did = ? and repo_at = ?`, starredByDid, repoAt)

     

       55
       55
       +
       func DeleteStar(e Execer, did string, subjectAt syntax.ATURI) error {

     

       56
       56
       +
       	_, err := e.Exec(`delete from stars where did = ? and subject_at = ?`, did, subjectAt)

     

       56
       57
        
       	return err

     

       57
       58
        
       }

     

       58
       59
        
       

     

       59
       60
        
       // Remove a star

     

       60
       60
       -
       func DeleteStarByRkey(e Execer, starredByDid string, rkey string) error {

     

       61
       61
       -
       	_, err := e.Exec(`delete from stars where starred_by_did = ? and rkey = ?`, starredByDid, rkey)

     

       61
       61
       +
       func DeleteStarByRkey(e Execer, did string, rkey string) error {

     

       62
       62
       +
       	_, err := e.Exec(`delete from stars where did = ? and rkey = ?`, did, rkey)

     

       62
       63
        
       	return err

     

       63
       64
        
       }

     

       64
       65
        
       

     

       65
       65
       -
       func GetStarCount(e Execer, repoAt syntax.ATURI) (int, error) {

     

       66
       66
       +
       func GetStarCount(e Execer, subjectAt syntax.ATURI) (int, error) {

     

       66
       67
        
       	stars := 0

     

       67
       68
        
       	err := e.QueryRow(

     

       68
       68
       -
       		`select count(starred_by_did) from stars where repo_at = ?`, repoAt).Scan(&stars)

     

       69
       69
       +
       		`select count(did) from stars where subject_at = ?`, subjectAt).Scan(&stars)

     

       69
       70
        
       	if err != nil {

     

       70
       71
        
       		return 0, err

     

       71
       72
        
       	}

     
···

       89
       90
        
       	}

     

       90
       91
        
       

     

       91
       92
        
       	query := fmt.Sprintf(`

     

       92
       92
       -
       		SELECT repo_at

     

       93
       93
       +
       		SELECT subject_at

     

       93
       94
        
       		FROM stars

     

       94
       94
       -
       		WHERE starred_by_did = ? AND repo_at IN (%s)

     

       95
       95
       +
       		WHERE did = ? AND subject_at IN (%s)

     

       95
       96
        
       	`, strings.Join(placeholders, ","))

     

       96
       97
        
       

     

       97
       98
        
       	rows, err := e.Query(query, args...)

     
···

       118
       119
        
       	return result, nil

     

       119
       120
        
       }

     

       120
       121
        
       

     

       121
       121
       -
       func GetStarStatus(e Execer, userDid string, repoAt syntax.ATURI) bool {

     

       122
       122
       -
       	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{repoAt})

     

       122
       122
       +
       func GetStarStatus(e Execer, userDid string, subjectAt syntax.ATURI) bool {

     

       123
       123
       +
       	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{subjectAt})

     

       123
       124
        
       	if err != nil {

     

       124
       125
        
       		return false

     

       125
       126
        
       	}

     

       126
       126
       -
       	return statuses[repoAt.String()]

     

       127
       127
       +
       	return statuses[subjectAt.String()]

     

       127
       128
        
       }

     

       128
       129
        
       

     

       129
       130
        
       // GetStarStatuses returns a map of repo URIs to star status for a given user

     

       130
       130
       -
       func GetStarStatuses(e Execer, userDid string, repoAts []syntax.ATURI) (map[string]bool, error) {

     

       131
       131
       -
       	return getStarStatuses(e, userDid, repoAts)

     

       131
       131
       +
       func GetStarStatuses(e Execer, userDid string, subjectAts []syntax.ATURI) (map[string]bool, error) {

     

       132
       132
       +
       	return getStarStatuses(e, userDid, subjectAts)

     

       132
       133
        
       }

     

       133
       133
       -
       func GetStars(e Execer, limit int, filters ...filter) ([]models.Star, error) {

     

       134
       134
       +
       

     

       135
       135
       +
       // GetRepoStars return a list of stars each holding target repository.

     

       136
       136
       +
       // If there isn't known repo with starred at-uri, those stars will be ignored.

     

       137
       137
       +
       func GetRepoStars(e Execer, limit int, filters ...orm.Filter) ([]models.RepoStar, error) {

     

       134
       138
        
       	var conditions []string

     

       135
       139
        
       	var args []any

     

       136
       140
        
       	for _, filter := range filters {

     
···

       149
       153
        
       	}

     

       150
       154
        
       

     

       151
       155
        
       	repoQuery := fmt.Sprintf(

     

       152
       152
       -
       		`select starred_by_did, repo_at, created, rkey

     

       156
       156
       +
       		`select did, subject_at, created, rkey

     

       153
       157
        
       		from stars

     

       154
       158
        
       		%s

     

       155
       159
        
       		order by created desc

     
···

       166
       170
        
       	for rows.Next() {

     

       167
       171
        
       		var star models.Star

     

       168
       172
        
       		var created string

     

       169
       169
       -
       		err := rows.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)

     

       173
       173
       +
       		err := rows.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)

     

       170
       174
        
       		if err != nil {

     

       171
       175
        
       			return nil, err

     

       172
       176
        
       		}

     
···

       192
       196
        
       		return nil, nil

     

       193
       197
        
       	}

     

       194
       198
        
       

     

       195
       195
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", args))

     

       199
       199
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", args))

     

       196
       200
        
       	if err != nil {

     

       197
       201
        
       		return nil, err

     

       198
       202
        
       	}

     

       199
       203
        
       

     

       204
       204
       +
       	var repoStars []models.RepoStar

     

       200
       205
        
       	for _, r := range repos {

     

       201
       206
        
       		if stars, ok := starMap[string(r.RepoAt())]; ok {

     

       202
       202
       -
       			for i := range stars {

     

       203
       203
       -
       				stars[i].Repo = &r

     

       207
       207
       +
       			for _, star := range stars {

     

       208
       208
       +
       				repoStars = append(repoStars, models.RepoStar{

     

       209
       209
       +
       					Star: star,

     

       210
       210
       +
       					Repo: &r,

     

       211
       211
       +
       				})

     

       204
       212
        
       			}

     

       205
       213
        
       		}

     

       206
       214
        
       	}

     

       207
       215
        
       

     

       208
       208
       -
       	var stars []models.Star

     

       209
       209
       -
       	for _, s := range starMap {

     

       210
       210
       -
       		stars = append(stars, s...)

     

       211
       211
       -
       	}

     

       212
       212
       -
       

     

       213
       213
       -
       	slices.SortFunc(stars, func(a, b models.Star) int {

     

       216
       216
       +
       	slices.SortFunc(repoStars, func(a, b models.RepoStar) int {

     

       214
       217
        
       		if a.Created.After(b.Created) {

     

       215
       218
        
       			return -1

     

       216
       219
        
       		}

     
···

       220
       223
        
       		return 0

     

       221
       224
        
       	})

     

       222
       225
        
       

     

       223
       223
       -
       	return stars, nil

     

       226
       226
       +
       	return repoStars, nil

     

       224
       227
        
       }

     

       225
       228
        
       

     

       226
       226
       -
       func CountStars(e Execer, filters ...filter) (int64, error) {

     

       229
       229
       +
       func CountStars(e Execer, filters ...orm.Filter) (int64, error) {

     

       227
       230
        
       	var conditions []string

     

       228
       231
        
       	var args []any

     

       229
       232
        
       	for _, filter := range filters {

     
···

       247
       250
        
       	return count, nil

     

       248
       251
        
       }

     

       249
       252
        
       

     

       250
       250
       -
       func GetAllStars(e Execer, limit int) ([]models.Star, error) {

     

       251
       251
       -
       	var stars []models.Star

     

       252
       252
       -
       

     

       253
       253
       -
       	rows, err := e.Query(`

     

       254
       254
       -
       		select

     

       255
       255
       -
       			s.starred_by_did,

     

       256
       256
       -
       			s.repo_at,

     

       257
       257
       -
       			s.rkey,

     

       258
       258
       -
       			s.created,

     

       259
       259
       -
       			r.did,

     

       260
       260
       -
       			r.name,

     

       261
       261
       -
       			r.knot,

     

       262
       262
       -
       			r.rkey,

     

       263
       263
       -
       			r.created

     

       264
       264
       -
       		from stars s

     

       265
       265
       -
       		join repos r on s.repo_at = r.at_uri

     

       266
       266
       -
       	`)

     

       267
       267
       -
       

     

       268
       268
       -
       	if err != nil {

     

       269
       269
       -
       		return nil, err

     

       270
       270
       -
       	}

     

       271
       271
       -
       	defer rows.Close()

     

       272
       272
       -
       

     

       273
       273
       -
       	for rows.Next() {

     

       274
       274
       -
       		var star models.Star

     

       275
       275
       -
       		var repo models.Repo

     

       276
       276
       -
       		var starCreatedAt, repoCreatedAt string

     

       277
       277
       -
       

     

       278
       278
       -
       		if err := rows.Scan(

     

       279
       279
       -
       			&star.StarredByDid,

     

       280
       280
       -
       			&star.RepoAt,

     

       281
       281
       -
       			&star.Rkey,

     

       282
       282
       -
       			&starCreatedAt,

     

       283
       283
       -
       			&repo.Did,

     

       284
       284
       -
       			&repo.Name,

     

       285
       285
       -
       			&repo.Knot,

     

       286
       286
       -
       			&repo.Rkey,

     

       287
       287
       -
       			&repoCreatedAt,

     

       288
       288
       -
       		); err != nil {

     

       289
       289
       -
       			return nil, err

     

       290
       290
       -
       		}

     

       291
       291
       -
       

     

       292
       292
       -
       		star.Created, err = time.Parse(time.RFC3339, starCreatedAt)

     

       293
       293
       -
       		if err != nil {

     

       294
       294
       -
       			star.Created = time.Now()

     

       295
       295
       -
       		}

     

       296
       296
       -
       		repo.Created, err = time.Parse(time.RFC3339, repoCreatedAt)

     

       297
       297
       -
       		if err != nil {

     

       298
       298
       -
       			repo.Created = time.Now()

     

       299
       299
       -
       		}

     

       300
       300
       -
       		star.Repo = &repo

     

       301
       301
       -
       

     

       302
       302
       -
       		stars = append(stars, star)

     

       303
       303
       -
       	}

     

       304
       304
       -
       

     

       305
       305
       -
       	if err := rows.Err(); err != nil {

     

       306
       306
       -
       		return nil, err

     

       307
       307
       -
       	}

     

       308
       308
       -
       

     

       309
       309
       -
       	return stars, nil

     

       310
       310
       -
       }

     

       311
       311
       -
       

     

       312
       253
        
       // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week

     

       313
       254
        
       func GetTopStarredReposLastWeek(e Execer) ([]models.Repo, error) {

     

       314
       255
        
       	// first, get the top repo URIs by star count from the last week

     

       315
       256
        
       	query := `

     

       316
       257
        
       		with recent_starred_repos as (

     

       317
       317
       -
       			select distinct repo_at

     

       258
       258
       +
       			select distinct subject_at

     

       318
       259
        
       			from stars

     

       319
       260
        
       			where created >= datetime('now', '-7 days')

     

       320
       261
        
       		),

     

       321
       262
        
       		repo_star_counts as (

     

       322
       263
        
       			select

     

       323
       323
       -
       				s.repo_at,

     

       264
       264
       +
       				s.subject_at,

     

       324
       265
        
       				count(*) as stars_gained_last_week

     

       325
       266
        
       			from stars s

     

       326
       326
       -
       			join recent_starred_repos rsr on s.repo_at = rsr.repo_at

     

       267
       267
       +
       			join recent_starred_repos rsr on s.subject_at = rsr.subject_at

     

       327
       268
        
       			where s.created >= datetime('now', '-7 days')

     

       328
       328
       -
       			group by s.repo_at

     

       269
       269
       +
       			group by s.subject_at

     

       329
       270
        
       		)

     

       330
       330
       -
       		select rsc.repo_at

     

       271
       271
       +
       		select rsc.subject_at

     

       331
       272
        
       		from repo_star_counts rsc

     

       332
       273
        
       		order by rsc.stars_gained_last_week desc

     

       333
       274
        
       		limit 8

     
···

       358
       299
        
       	}

     

       359
       300
        
       

     

       360
       301
        
       	// get full repo data

     

       361
       361
       -
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoUris))

     

       302
       302
       +
       	repos, err := GetRepos(e, 0, orm.FilterIn("at_uri", repoUris))

     

       362
       303
        
       	if err != nil {

     

       363
       304
        
       		return nil, err

     

       364
       305
        
       	}

+4 -3

appview/db/strings.go

···

       8
       8
        
       	"time"

     

       9
       9
        
       

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

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

     

       11
       12
        
       )

     

       12
       13
        
       

     

       13
       14
        
       func AddString(e Execer, s models.String) error {

     
···

       44
       45
        
       	return err

     

       45
       46
        
       }

     

       46
       47
        
       

     

       47
       47
       -
       func GetStrings(e Execer, limit int, filters ...filter) ([]models.String, error) {

     

       48
       48
       +
       func GetStrings(e Execer, limit int, filters ...orm.Filter) ([]models.String, error) {

     

       48
       49
        
       	var all []models.String

     

       49
       50
        
       

     

       50
       51
        
       	var conditions []string

     
···

       127
       128
        
       	return all, nil

     

       128
       129
        
       }

     

       129
       130
        
       

     

       130
       130
       -
       func CountStrings(e Execer, filters ...filter) (int64, error) {

     

       131
       131
       +
       func CountStrings(e Execer, filters ...orm.Filter) (int64, error) {

     

       131
       132
        
       	var conditions []string

     

       132
       133
        
       	var args []any

     

       133
       134
        
       	for _, filter := range filters {

     
···

       151
       152
        
       	return count, nil

     

       152
       153
        
       }

     

       153
       154
        
       

     

       154
       154
       -
       func DeleteString(e Execer, filters ...filter) error {

     

       155
       155
       +
       func DeleteString(e Execer, filters ...orm.Filter) error {

     

       155
       156
        
       	var conditions []string

     

       156
       157
        
       	var args []any

     

       157
       158
        
       	for _, filter := range filters {

+11 -20

appview/db/timeline.go

···

       5
       5
        
       

     

       6
       6
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

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

     

       8
       8
       +
       	"tangled.org/core/orm"

     

       8
       9
        
       )

     

       9
       10
        
       

     

       10
       11
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     
···

       84
       85
        
       }

     

       85
       86
        
       

     

       86
       87
        
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       87
       87
       -
       	filters := make([]filter, 0)

     

       88
       88
       +
       	filters := make([]orm.Filter, 0)

     

       88
       89
        
       	if userIsFollowing != nil {

     

       89
       89
       -
       		filters = append(filters, FilterIn("did", userIsFollowing))

     

       90
       90
       +
       		filters = append(filters, orm.FilterIn("did", userIsFollowing))

     

       90
       91
        
       	}

     

       91
       92
        
       

     

       92
       93
        
       	repos, err := GetRepos(e, limit, filters...)

     
···

       104
       105
        
       

     

       105
       106
        
       	var origRepos []models.Repo

     

       106
       107
        
       	if args != nil {

     

       107
       107
       -
       		origRepos, err = GetRepos(e, 0, FilterIn("at_uri", args))

     

       108
       108
       +
       		origRepos, err = GetRepos(e, 0, orm.FilterIn("at_uri", args))

     

       108
       109
        
       	}

     

       109
       110
        
       	if err != nil {

     

       110
       111
        
       		return nil, err

     
···

       144
       145
        
       }

     

       145
       146
        
       

     

       146
       147
        
       func getTimelineStars(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       147
       147
       -
       	filters := make([]filter, 0)

     

       148
       148
       +
       	filters := make([]orm.Filter, 0)

     

       148
       149
        
       	if userIsFollowing != nil {

     

       149
       149
       -
       		filters = append(filters, FilterIn("starred_by_did", userIsFollowing))

     

       150
       150
       +
       		filters = append(filters, orm.FilterIn("did", userIsFollowing))

     

       150
       151
        
       	}

     

       151
       152
        
       

     

       152
       152
       -
       	stars, err := GetStars(e, limit, filters...)

     

       153
       153
       +
       	stars, err := GetRepoStars(e, limit, filters...)

     

       153
       154
        
       	if err != nil {

     

       154
       155
        
       		return nil, err

     

       155
       156
        
       	}

     

       156
       157
        
       

     

       157
       157
       -
       	// filter star records without a repo

     

       158
       158
       -
       	n := 0

     

       159
       159
       -
       	for _, s := range stars {

     

       160
       160
       -
       		if s.Repo != nil {

     

       161
       161
       -
       			stars[n] = s

     

       162
       162
       -
       			n++

     

       163
       163
       -
       		}

     

       164
       164
       -
       	}

     

       165
       165
       -
       	stars = stars[:n]

     

       166
       166
       -
       

     

       167
       158
        
       	var repos []models.Repo

     

       168
       159
        
       	for _, s := range stars {

     

       169
       160
        
       		repos = append(repos, *s.Repo)

     
···

       179
       170
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       180
       171
        
       

     

       181
       172
        
       		events = append(events, models.TimelineEvent{

     

       182
       182
       -
       			Star:      &s,

     

       173
       173
       +
       			RepoStar:  &s,

     

       183
       174
        
       			EventAt:   s.Created,

     

       184
       175
        
       			IsStarred: isStarred,

     

       185
       176
        
       			StarCount: starCount,

     
···

       190
       181
        
       }

     

       191
       182
        
       

     

       192
       183
        
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {

     

       193
       193
       -
       	filters := make([]filter, 0)

     

       184
       184
       +
       	filters := make([]orm.Filter, 0)

     

       194
       185
        
       	if userIsFollowing != nil {

     

       195
       195
       -
       		filters = append(filters, FilterIn("user_did", userIsFollowing))

     

       186
       186
       +
       		filters = append(filters, orm.FilterIn("user_did", userIsFollowing))

     

       196
       187
        
       	}

     

       197
       188
        
       

     

       198
       189
        
       	follows, err := GetFollows(e, limit, filters...)

     
···

       209
       200
        
       		return nil, nil

     

       210
       201
        
       	}

     

       211
       202
        
       

     

       212
       212
       -
       	profiles, err := GetProfiles(e, FilterIn("did", subjects))

     

       203
       203
       +
       	profiles, err := GetProfiles(e, orm.FilterIn("did", subjects))

     

       213
       204
        
       	if err != nil {

     

       214
       205
        
       		return nil, err

     

       215
       206
        
       	}

+7 -12

appview/email/email.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
        
       	"net"

     

       6
       6
       -
       	"regexp"

     

       6
       6
       +
       	"net/mail"

     

       7
       7
        
       	"strings"

     

       8
       8
        
       

     

       9
       9
        
       	"github.com/resend/resend-go/v2"

     
···

       34
       34
        
       }

     

       35
       35
        
       

     

       36
       36
        
       func IsValidEmail(email string) bool {

     

       37
       37
       -
       	// Basic length check

     

       38
       38
       -
       	if len(email) < 3 || len(email) > 254 {

     

       37
       37
       +
       	// Reject whitespace (ParseAddress normalizes it away)

     

       38
       38
       +
       	if strings.ContainsAny(email, " \t\n\r") {

     

       39
       39
        
       		return false

     

       40
       40
        
       	}

     

       41
       41
        
       

     

       42
       42
       -
       	// Regular expression for email validation (RFC 5322 compliant)

     

       43
       43
       -
       	pattern := `^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$`

     

       44
       44
       -
       

     

       45
       45
       -
       	// Compile regex

     

       46
       46
       -
       	regex := regexp.MustCompile(pattern)

     

       47
       47
       -
       

     

       48
       48
       -
       	// Check if email matches regex pattern

     

       49
       49
       -
       	if !regex.MatchString(email) {

     

       42
       42
       +
       	// Use stdlib RFC 5322 parser

     

       43
       43
       +
       	addr, err := mail.ParseAddress(email)

     

       44
       44
       +
       	if err != nil {

     

       50
       45
        
       		return false

     

       51
       46
        
       	}

     

       52
       47
        
       

     

       53
       48
        
       	// Split email into local and domain parts

     

       54
       54
       -
       	parts := strings.Split(email, "@")

     

       49
       49
       +
       	parts := strings.Split(addr.Address, "@")

     

       55
       50
        
       	domain := parts[1]

     

       56
       51
        
       

     

       57
       52
        
       	mx, err := net.LookupMX(domain)

+53

appview/email/email_test.go

···

       1
       1
       +
       package email

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestIsValidEmail(t *testing.T) {

     

       8
       8
       +
       	tests := []struct {

     

       9
       9
       +
       		name  string

     

       10
       10
       +
       		email string

     

       11
       11
       +
       		want  bool

     

       12
       12
       +
       	}{

     

       13
       13
       +
       		// Valid emails using RFC 2606 reserved domains

     

       14
       14
       +
       		{"standard email", "user@example.com", true},

     

       15
       15
       +
       		{"single char local", "a@example.com", true},

     

       16
       16
       +
       		{"dot in middle", "first.last@example.com", true},

     

       17
       17
       +
       		{"multiple dots", "a.b.c@example.com", true},

     

       18
       18
       +
       		{"plus tag", "user+tag@example.com", true},

     

       19
       19
       +
       		{"numbers", "user123@example.com", true},

     

       20
       20
       +
       		{"example.org", "user@example.org", true},

     

       21
       21
       +
       		{"example.net", "user@example.net", true},

     

       22
       22
       +
       

     

       23
       23
       +
       		// Invalid format - rejected by mail.ParseAddress

     

       24
       24
       +
       		{"empty string", "", false},

     

       25
       25
       +
       		{"no at sign", "userexample.com", false},

     

       26
       26
       +
       		{"no domain", "user@", false},

     

       27
       27
       +
       		{"no local part", "@example.com", false},

     

       28
       28
       +
       		{"double at", "user@@example.com", false},

     

       29
       29
       +
       		{"just at sign", "@", false},

     

       30
       30
       +
       		{"leading dot", ".user@example.com", false},

     

       31
       31
       +
       		{"trailing dot", "user.@example.com", false},

     

       32
       32
       +
       		{"consecutive dots", "user..name@example.com", false},

     

       33
       33
       +
       

     

       34
       34
       +
       		// Whitespace - rejected before parsing

     

       35
       35
       +
       		{"space in local", "user @example.com", false},

     

       36
       36
       +
       		{"space in domain", "user@ example.com", false},

     

       37
       37
       +
       		{"tab", "user\t@example.com", false},

     

       38
       38
       +
       		{"newline", "user\n@example.com", false},

     

       39
       39
       +
       

     

       40
       40
       +
       		// MX lookup - using RFC 2606 reserved TLDs (guaranteed no MX)

     

       41
       41
       +
       		{"invalid TLD", "user@example.invalid", false},

     

       42
       42
       +
       		{"test TLD", "user@mail.test", false},

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	for _, tt := range tests {

     

       46
       46
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       47
       47
       +
       			got := IsValidEmail(tt.email)

     

       48
       48
       +
       			if got != tt.want {

     

       49
       49
       +
       				t.Errorf("IsValidEmail(%q) = %v, want %v", tt.email, got, tt.want)

     

       50
       50
       +
       			}

     

       51
       51
       +
       		})

     

       52
       52
       +
       	}

     

       53
       53
       +
       }

+20

appview/indexer/base36/base36.go

···

       1
       1
       +
       // mostly copied from gitea/modules/indexer/internal/base32

     

       2
       2
       +
       

     

       3
       3
       +
       package base36

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"strconv"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       func Encode(i int64) string {

     

       11
       11
       +
       	return strconv.FormatInt(i, 36)

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       func Decode(s string) (int64, error) {

     

       15
       15
       +
       	i, err := strconv.ParseInt(s, 36, 64)

     

       16
       16
       +
       	if err != nil {

     

       17
       17
       +
       		return 0, fmt.Errorf("invalid base36 integer %q: %w", s, err)

     

       18
       18
       +
       	}

     

       19
       19
       +
       	return i, nil

     

       20
       20
       +
       }

+58

appview/indexer/bleve/batch.go

···

       1
       1
       +
       // Copyright 2021 The Gitea Authors. All rights reserved.

     

       2
       2
       +
       // SPDX-License-Identifier: MIT

     

       3
       3
       +
       

     

       4
       4
       +
       package bleveutil

     

       5
       5
       +
       

     

       6
       6
       +
       import (

     

       7
       7
       +
       	"github.com/blevesearch/bleve/v2"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // FlushingBatch is a batch of operations that automatically flushes to the

     

       11
       11
       +
       // underlying index once it reaches a certain size.

     

       12
       12
       +
       type FlushingBatch struct {

     

       13
       13
       +
       	maxBatchSize int

     

       14
       14
       +
       	batch        *bleve.Batch

     

       15
       15
       +
       	index        bleve.Index

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       // NewFlushingBatch creates a new flushing batch for the specified index. Once

     

       19
       19
       +
       // the number of operations in the batch reaches the specified limit, the batch

     

       20
       20
       +
       // automatically flushes its operations to the index.

     

       21
       21
       +
       func NewFlushingBatch(index bleve.Index, maxBatchSize int) *FlushingBatch {

     

       22
       22
       +
       	return &FlushingBatch{

     

       23
       23
       +
       		maxBatchSize: maxBatchSize,

     

       24
       24
       +
       		batch:        index.NewBatch(),

     

       25
       25
       +
       		index:        index,

     

       26
       26
       +
       	}

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       // Index add a new index to batch

     

       30
       30
       +
       func (b *FlushingBatch) Index(id string, data any) error {

     

       31
       31
       +
       	if err := b.batch.Index(id, data); err != nil {

     

       32
       32
       +
       		return err

     

       33
       33
       +
       	}

     

       34
       34
       +
       	return b.flushIfFull()

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       // Delete add a delete index to batch

     

       38
       38
       +
       func (b *FlushingBatch) Delete(id string) error {

     

       39
       39
       +
       	b.batch.Delete(id)

     

       40
       40
       +
       	return b.flushIfFull()

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func (b *FlushingBatch) flushIfFull() error {

     

       44
       44
       +
       	if b.batch.Size() < b.maxBatchSize {

     

       45
       45
       +
       		return nil

     

       46
       46
       +
       	}

     

       47
       47
       +
       	return b.Flush()

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       // Flush submit the batch and create a new one

     

       51
       51
       +
       func (b *FlushingBatch) Flush() error {

     

       52
       52
       +
       	err := b.index.Batch(b.batch)

     

       53
       53
       +
       	if err != nil {

     

       54
       54
       +
       		return err

     

       55
       55
       +
       	}

     

       56
       56
       +
       	b.batch = b.index.NewBatch()

     

       57
       57
       +
       	return nil

     

       58
       58
       +
       }

+26

appview/indexer/bleve/query.go

···

       1
       1
       +
       package bleveutil

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"github.com/blevesearch/bleve/v2"

     

       5
       5
       +
       	"github.com/blevesearch/bleve/v2/search/query"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       func MatchAndQuery(field, keyword, analyzer string, fuzziness int) query.Query {

     

       9
       9
       +
       	q := bleve.NewMatchQuery(keyword)

     

       10
       10
       +
       	q.FieldVal = field

     

       11
       11
       +
       	q.Analyzer = analyzer

     

       12
       12
       +
       	q.Fuzziness = fuzziness

     

       13
       13
       +
       	return q

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       func BoolFieldQuery(field string, val bool) query.Query {

     

       17
       17
       +
       	q := bleve.NewBoolFieldQuery(val)

     

       18
       18
       +
       	q.FieldVal = field

     

       19
       19
       +
       	return q

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func KeywordFieldQuery(field, keyword string) query.Query {

     

       23
       23
       +
       	q := bleve.NewTermQuery(keyword)

     

       24
       24
       +
       	q.FieldVal = field

     

       25
       25
       +
       	return q

     

       26
       26
       +
       }

+36

appview/indexer/indexer.go

···

       1
       1
       +
       package indexer

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	issues_indexer "tangled.org/core/appview/indexer/issues"

     

       9
       9
       +
       	pulls_indexer "tangled.org/core/appview/indexer/pulls"

     

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

     

       11
       11
       +
       	tlog "tangled.org/core/log"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       type Indexer struct {

     

       15
       15
       +
       	Issues *issues_indexer.Indexer

     

       16
       16
       +
       	Pulls  *pulls_indexer.Indexer

     

       17
       17
       +
       	logger *slog.Logger

     

       18
       18
       +
       	notify.BaseNotifier

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func New(logger *slog.Logger) *Indexer {

     

       22
       22
       +
       	return &Indexer{

     

       23
       23
       +
       		issues_indexer.NewIndexer("indexes/issues.bleve"),

     

       24
       24
       +
       		pulls_indexer.NewIndexer("indexes/pulls.bleve"),

     

       25
       25
       +
       		logger,

     

       26
       26
       +
       		notify.BaseNotifier{},

     

       27
       27
       +
       	}

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       // Init initializes all indexers

     

       31
       31
       +
       func (ix *Indexer) Init(ctx context.Context, db *db.DB) error {

     

       32
       32
       +
       	ctx = tlog.IntoContext(ctx, ix.logger)

     

       33
       33
       +
       	ix.Issues.Init(ctx, db)

     

       34
       34
       +
       	ix.Pulls.Init(ctx, db)

     

       35
       35
       +
       	return nil

     

       36
       36
       +
       }

+257

appview/indexer/issues/indexer.go

···

       1
       1
       +
       // heavily inspired by gitea's model (basically copy-pasted)

     

       2
       2
       +
       package issues_indexer

     

       3
       3
       +
       

     

       4
       4
       +
       import (

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"os"

     

       9
       9
       +
       

     

       10
       10
       +
       	"github.com/blevesearch/bleve/v2"

     

       11
       11
       +
       	"github.com/blevesearch/bleve/v2/analysis/analyzer/custom"

     

       12
       12
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/camelcase"

     

       13
       13
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/lowercase"

     

       14
       14
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/unicodenorm"

     

       15
       15
       +
       	"github.com/blevesearch/bleve/v2/analysis/tokenizer/unicode"

     

       16
       16
       +
       	"github.com/blevesearch/bleve/v2/index/upsidedown"

     

       17
       17
       +
       	"github.com/blevesearch/bleve/v2/mapping"

     

       18
       18
       +
       	"github.com/blevesearch/bleve/v2/search/query"

     

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

     

       20
       20
       +
       	"tangled.org/core/appview/indexer/base36"

     

       21
       21
       +
       	"tangled.org/core/appview/indexer/bleve"

     

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

     

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

     

       24
       24
       +
       	tlog "tangled.org/core/log"

     

       25
       25
       +
       )

     

       26
       26
       +
       

     

       27
       27
       +
       const (

     

       28
       28
       +
       	issueIndexerAnalyzer = "issueIndexer"

     

       29
       29
       +
       	issueIndexerDocType  = "issueIndexerDocType"

     

       30
       30
       +
       

     

       31
       31
       +
       	unicodeNormalizeName = "uicodeNormalize"

     

       32
       32
       +
       )

     

       33
       33
       +
       

     

       34
       34
       +
       type Indexer struct {

     

       35
       35
       +
       	indexer bleve.Index

     

       36
       36
       +
       	path    string

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func NewIndexer(indexDir string) *Indexer {

     

       40
       40
       +
       	return &Indexer{

     

       41
       41
       +
       		path: indexDir,

     

       42
       42
       +
       	}

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       // Init initializes the indexer

     

       46
       46
       +
       func (ix *Indexer) Init(ctx context.Context, e db.Execer) {

     

       47
       47
       +
       	l := tlog.FromContext(ctx)

     

       48
       48
       +
       	existed, err := ix.intialize(ctx)

     

       49
       49
       +
       	if err != nil {

     

       50
       50
       +
       		log.Fatalln("failed to initialize issue indexer", err)

     

       51
       51
       +
       	}

     

       52
       52
       +
       	if !existed {

     

       53
       53
       +
       		l.Debug("Populating the issue indexer")

     

       54
       54
       +
       		err := PopulateIndexer(ctx, ix, e)

     

       55
       55
       +
       		if err != nil {

     

       56
       56
       +
       			log.Fatalln("failed to populate issue indexer", err)

     

       57
       57
       +
       		}

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	count, _ := ix.indexer.DocCount()

     

       61
       61
       +
       	l.Info("Initialized the issue indexer", "docCount", count)

     

       62
       62
       +
       }

     

       63
       63
       +
       

     

       64
       64
       +
       func generateIssueIndexMapping() (mapping.IndexMapping, error) {

     

       65
       65
       +
       	mapping := bleve.NewIndexMapping()

     

       66
       66
       +
       	docMapping := bleve.NewDocumentMapping()

     

       67
       67
       +
       

     

       68
       68
       +
       	textFieldMapping := bleve.NewTextFieldMapping()

     

       69
       69
       +
       	textFieldMapping.Store = false

     

       70
       70
       +
       	textFieldMapping.IncludeInAll = false

     

       71
       71
       +
       

     

       72
       72
       +
       	boolFieldMapping := bleve.NewBooleanFieldMapping()

     

       73
       73
       +
       	boolFieldMapping.Store = false

     

       74
       74
       +
       	boolFieldMapping.IncludeInAll = false

     

       75
       75
       +
       

     

       76
       76
       +
       	keywordFieldMapping := bleve.NewKeywordFieldMapping()

     

       77
       77
       +
       	keywordFieldMapping.Store = false

     

       78
       78
       +
       	keywordFieldMapping.IncludeInAll = false

     

       79
       79
       +
       

     

       80
       80
       +
       	// numericFieldMapping := bleve.NewNumericFieldMapping()

     

       81
       81
       +
       

     

       82
       82
       +
       	docMapping.AddFieldMappingsAt("title", textFieldMapping)

     

       83
       83
       +
       	docMapping.AddFieldMappingsAt("body", textFieldMapping)

     

       84
       84
       +
       

     

       85
       85
       +
       	docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping)

     

       86
       86
       +
       	docMapping.AddFieldMappingsAt("is_open", boolFieldMapping)

     

       87
       87
       +
       

     

       88
       88
       +
       	err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{

     

       89
       89
       +
       		"type": unicodenorm.Name,

     

       90
       90
       +
       		"form": unicodenorm.NFC,

     

       91
       91
       +
       	})

     

       92
       92
       +
       	if err != nil {

     

       93
       93
       +
       		return nil, err

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	err = mapping.AddCustomAnalyzer(issueIndexerAnalyzer, map[string]any{

     

       97
       97
       +
       		"type":          custom.Name,

     

       98
       98
       +
       		"char_filters":  []string{},

     

       99
       99
       +
       		"tokenizer":     unicode.Name,

     

       100
       100
       +
       		"token_filters": []string{unicodeNormalizeName, camelcase.Name, lowercase.Name},

     

       101
       101
       +
       	})

     

       102
       102
       +
       	if err != nil {

     

       103
       103
       +
       		return nil, err

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	mapping.DefaultAnalyzer = issueIndexerAnalyzer

     

       107
       107
       +
       	mapping.AddDocumentMapping(issueIndexerDocType, docMapping)

     

       108
       108
       +
       	mapping.AddDocumentMapping("_all", bleve.NewDocumentDisabledMapping())

     

       109
       109
       +
       	mapping.DefaultMapping = bleve.NewDocumentDisabledMapping()

     

       110
       110
       +
       

     

       111
       111
       +
       	return mapping, nil

     

       112
       112
       +
       }

     

       113
       113
       +
       

     

       114
       114
       +
       func (ix *Indexer) intialize(ctx context.Context) (bool, error) {

     

       115
       115
       +
       	if ix.indexer != nil {

     

       116
       116
       +
       		return false, errors.New("indexer is already initialized")

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	indexer, err := openIndexer(ctx, ix.path)

     

       120
       120
       +
       	if err != nil {

     

       121
       121
       +
       		return false, err

     

       122
       122
       +
       	}

     

       123
       123
       +
       	if indexer != nil {

     

       124
       124
       +
       		ix.indexer = indexer

     

       125
       125
       +
       		return true, nil

     

       126
       126
       +
       	}

     

       127
       127
       +
       

     

       128
       128
       +
       	mapping, err := generateIssueIndexMapping()

     

       129
       129
       +
       	if err != nil {

     

       130
       130
       +
       		return false, err

     

       131
       131
       +
       	}

     

       132
       132
       +
       	indexer, err = bleve.New(ix.path, mapping)

     

       133
       133
       +
       	if err != nil {

     

       134
       134
       +
       		return false, err

     

       135
       135
       +
       	}

     

       136
       136
       +
       

     

       137
       137
       +
       	ix.indexer = indexer

     

       138
       138
       +
       

     

       139
       139
       +
       	return false, nil

     

       140
       140
       +
       }

     

       141
       141
       +
       

     

       142
       142
       +
       func openIndexer(ctx context.Context, path string) (bleve.Index, error) {

     

       143
       143
       +
       	l := tlog.FromContext(ctx)

     

       144
       144
       +
       	indexer, err := bleve.Open(path)

     

       145
       145
       +
       	if err != nil {

     

       146
       146
       +
       		if errors.Is(err, upsidedown.IncompatibleVersion) {

     

       147
       147
       +
       			l.Info("Indexer was built with a previous version of bleve, deleting and rebuilding")

     

       148
       148
       +
       			return nil, os.RemoveAll(path)

     

       149
       149
       +
       		}

     

       150
       150
       +
       		return nil, nil

     

       151
       151
       +
       	}

     

       152
       152
       +
       	return indexer, nil

     

       153
       153
       +
       }

     

       154
       154
       +
       

     

       155
       155
       +
       func PopulateIndexer(ctx context.Context, ix *Indexer, e db.Execer) error {

     

       156
       156
       +
       	l := tlog.FromContext(ctx)

     

       157
       157
       +
       	count := 0

     

       158
       158
       +
       	err := pagination.IterateAll(

     

       159
       159
       +
       		func(page pagination.Page) ([]models.Issue, error) {

     

       160
       160
       +
       			return db.GetIssuesPaginated(e, page)

     

       161
       161
       +
       		},

     

       162
       162
       +
       		func(issues []models.Issue) error {

     

       163
       163
       +
       			count += len(issues)

     

       164
       164
       +
       			return ix.Index(ctx, issues...)

     

       165
       165
       +
       		},

     

       166
       166
       +
       	)

     

       167
       167
       +
       	l.Info("issues indexed", "count", count)

     

       168
       168
       +
       	return err

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       // issueData data stored and will be indexed

     

       172
       172
       +
       type issueData struct {

     

       173
       173
       +
       	ID      int64  `json:"id"`

     

       174
       174
       +
       	RepoAt  string `json:"repo_at"`

     

       175
       175
       +
       	IssueID int    `json:"issue_id"`

     

       176
       176
       +
       	Title   string `json:"title"`

     

       177
       177
       +
       	Body    string `json:"body"`

     

       178
       178
       +
       

     

       179
       179
       +
       	IsOpen   bool               `json:"is_open"`

     

       180
       180
       +
       	Comments []IssueCommentData `json:"comments"`

     

       181
       181
       +
       }

     

       182
       182
       +
       

     

       183
       183
       +
       func makeIssueData(issue *models.Issue) *issueData {

     

       184
       184
       +
       	return &issueData{

     

       185
       185
       +
       		ID:      issue.Id,

     

       186
       186
       +
       		RepoAt:  issue.RepoAt.String(),

     

       187
       187
       +
       		IssueID: issue.IssueId,

     

       188
       188
       +
       		Title:   issue.Title,

     

       189
       189
       +
       		Body:    issue.Body,

     

       190
       190
       +
       		IsOpen:  issue.Open,

     

       191
       191
       +
       	}

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       // Type returns the document type, for bleve's mapping.Classifier interface.

     

       195
       195
       +
       func (i *issueData) Type() string {

     

       196
       196
       +
       	return issueIndexerDocType

     

       197
       197
       +
       }

     

       198
       198
       +
       

     

       199
       199
       +
       type IssueCommentData struct {

     

       200
       200
       +
       	Body string `json:"body"`

     

       201
       201
       +
       }

     

       202
       202
       +
       

     

       203
       203
       +
       type SearchResult struct {

     

       204
       204
       +
       	Hits  []int64

     

       205
       205
       +
       	Total uint64

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

       208
       208
       +
       const maxBatchSize = 20

     

       209
       209
       +
       

     

       210
       210
       +
       func (ix *Indexer) Index(ctx context.Context, issues ...models.Issue) error {

     

       211
       211
       +
       	batch := bleveutil.NewFlushingBatch(ix.indexer, maxBatchSize)

     

       212
       212
       +
       	for _, issue := range issues {

     

       213
       213
       +
       		issueData := makeIssueData(&issue)

     

       214
       214
       +
       		if err := batch.Index(base36.Encode(issue.Id), issueData); err != nil {

     

       215
       215
       +
       			return err

     

       216
       216
       +
       		}

     

       217
       217
       +
       	}

     

       218
       218
       +
       	return batch.Flush()

     

       219
       219
       +
       }

     

       220
       220
       +
       

     

       221
       221
       +
       func (ix *Indexer) Delete(ctx context.Context, issueId int64) error {

     

       222
       222
       +
       	return ix.indexer.Delete(base36.Encode(issueId))

     

       223
       223
       +
       }

     

       224
       224
       +
       

     

       225
       225
       +
       // Search searches for issues

     

       226
       226
       +
       func (ix *Indexer) Search(ctx context.Context, opts models.IssueSearchOptions) (*SearchResult, error) {

     

       227
       227
       +
       	var queries []query.Query

     

       228
       228
       +
       

     

       229
       229
       +
       	if opts.Keyword != "" {

     

       230
       230
       +
       		queries = append(queries, bleve.NewDisjunctionQuery(

     

       231
       231
       +
       			bleveutil.MatchAndQuery("title", opts.Keyword, issueIndexerAnalyzer, 0),

     

       232
       232
       +
       			bleveutil.MatchAndQuery("body", opts.Keyword, issueIndexerAnalyzer, 0),

     

       233
       233
       +
       		))

     

       234
       234
       +
       	}

     

       235
       235
       +
       	queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt))

     

       236
       236
       +
       	queries = append(queries, bleveutil.BoolFieldQuery("is_open", opts.IsOpen))

     

       237
       237
       +
       	// TODO: append more queries

     

       238
       238
       +
       

     

       239
       239
       +
       	var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...)

     

       240
       240
       +
       	searchReq := bleve.NewSearchRequestOptions(indexerQuery, opts.Page.Limit, opts.Page.Offset, false)

     

       241
       241
       +
       	res, err := ix.indexer.SearchInContext(ctx, searchReq)

     

       242
       242
       +
       	if err != nil {

     

       243
       243
       +
       		return nil, nil

     

       244
       244
       +
       	}

     

       245
       245
       +
       	ret := &SearchResult{

     

       246
       246
       +
       		Total: res.Total,

     

       247
       247
       +
       		Hits:  make([]int64, len(res.Hits)),

     

       248
       248
       +
       	}

     

       249
       249
       +
       	for i, hit := range res.Hits {

     

       250
       250
       +
       		id, err := base36.Decode(hit.ID)

     

       251
       251
       +
       		if err != nil {

     

       252
       252
       +
       			return nil, err

     

       253
       253
       +
       		}

     

       254
       254
       +
       		ret.Hits[i] = id

     

       255
       255
       +
       	}

     

       256
       256
       +
       	return ret, nil

     

       257
       257
       +
       }

+57

appview/indexer/notifier.go

···

       1
       1
       +
       package indexer

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       

     

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

     

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

     

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

     

       9
       9
       +
       	"tangled.org/core/log"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       var _ notify.Notifier = &Indexer{}

     

       13
       13
       +
       

     

       14
       14
       +
       func (ix *Indexer) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {

     

       15
       15
       +
       	l := log.FromContext(ctx).With("notifier", "indexer", "issue", issue)

     

       16
       16
       +
       	l.Debug("indexing new issue")

     

       17
       17
       +
       	err := ix.Issues.Index(ctx, *issue)

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		l.Error("failed to index an issue", "err", err)

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func (ix *Indexer) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

     

       24
       24
       +
       	l := log.FromContext(ctx).With("notifier", "indexer", "issue", issue)

     

       25
       25
       +
       	l.Debug("updating an issue")

     

       26
       26
       +
       	err := ix.Issues.Index(ctx, *issue)

     

       27
       27
       +
       	if err != nil {

     

       28
       28
       +
       		l.Error("failed to index an issue", "err", err)

     

       29
       29
       +
       	}

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       func (ix *Indexer) DeleteIssue(ctx context.Context, issue *models.Issue) {

     

       33
       33
       +
       	l := log.FromContext(ctx).With("notifier", "indexer", "issue", issue)

     

       34
       34
       +
       	l.Debug("deleting an issue")

     

       35
       35
       +
       	err := ix.Issues.Delete(ctx, issue.Id)

     

       36
       36
       +
       	if err != nil {

     

       37
       37
       +
       		l.Error("failed to delete an issue", "err", err)

     

       38
       38
       +
       	}

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       func (ix *Indexer) NewPull(ctx context.Context, pull *models.Pull) {

     

       42
       42
       +
       	l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull)

     

       43
       43
       +
       	l.Debug("indexing new pr")

     

       44
       44
       +
       	err := ix.Pulls.Index(ctx, pull)

     

       45
       45
       +
       	if err != nil {

     

       46
       46
       +
       		l.Error("failed to index a pr", "err", err)

     

       47
       47
       +
       	}

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       func (ix *Indexer) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

     

       51
       51
       +
       	l := log.FromContext(ctx).With("notifier", "indexer", "pull", pull)

     

       52
       52
       +
       	l.Debug("updating a pr")

     

       53
       53
       +
       	err := ix.Pulls.Index(ctx, pull)

     

       54
       54
       +
       	if err != nil {

     

       55
       55
       +
       		l.Error("failed to index a pr", "err", err)

     

       56
       56
       +
       	}

     

       57
       57
       +
       }

+257

appview/indexer/pulls/indexer.go

···

       1
       1
       +
       // heavily inspired by gitea's model (basically copy-pasted)

     

       2
       2
       +
       package pulls_indexer

     

       3
       3
       +
       

     

       4
       4
       +
       import (

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"log"

     

       8
       8
       +
       	"os"

     

       9
       9
       +
       

     

       10
       10
       +
       	"github.com/blevesearch/bleve/v2"

     

       11
       11
       +
       	"github.com/blevesearch/bleve/v2/analysis/analyzer/custom"

     

       12
       12
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/camelcase"

     

       13
       13
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/lowercase"

     

       14
       14
       +
       	"github.com/blevesearch/bleve/v2/analysis/token/unicodenorm"

     

       15
       15
       +
       	"github.com/blevesearch/bleve/v2/analysis/tokenizer/unicode"

     

       16
       16
       +
       	"github.com/blevesearch/bleve/v2/index/upsidedown"

     

       17
       17
       +
       	"github.com/blevesearch/bleve/v2/mapping"

     

       18
       18
       +
       	"github.com/blevesearch/bleve/v2/search/query"

     

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

     

       20
       20
       +
       	"tangled.org/core/appview/indexer/base36"

     

       21
       21
       +
       	"tangled.org/core/appview/indexer/bleve"

     

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

     

       23
       23
       +
       	tlog "tangled.org/core/log"

     

       24
       24
       +
       )

     

       25
       25
       +
       

     

       26
       26
       +
       const (

     

       27
       27
       +
       	pullIndexerAnalyzer = "pullIndexer"

     

       28
       28
       +
       	pullIndexerDocType  = "pullIndexerDocType"

     

       29
       29
       +
       

     

       30
       30
       +
       	unicodeNormalizeName = "uicodeNormalize"

     

       31
       31
       +
       )

     

       32
       32
       +
       

     

       33
       33
       +
       type Indexer struct {

     

       34
       34
       +
       	indexer bleve.Index

     

       35
       35
       +
       	path    string

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       func NewIndexer(indexDir string) *Indexer {

     

       39
       39
       +
       	return &Indexer{

     

       40
       40
       +
       		path: indexDir,

     

       41
       41
       +
       	}

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       // Init initializes the indexer

     

       45
       45
       +
       func (ix *Indexer) Init(ctx context.Context, e db.Execer) {

     

       46
       46
       +
       	l := tlog.FromContext(ctx)

     

       47
       47
       +
       	existed, err := ix.intialize(ctx)

     

       48
       48
       +
       	if err != nil {

     

       49
       49
       +
       		log.Fatalln("failed to initialize pull indexer", err)

     

       50
       50
       +
       	}

     

       51
       51
       +
       	if !existed {

     

       52
       52
       +
       		l.Debug("Populating the pull indexer")

     

       53
       53
       +
       		err := PopulateIndexer(ctx, ix, e)

     

       54
       54
       +
       		if err != nil {

     

       55
       55
       +
       			log.Fatalln("failed to populate pull indexer", err)

     

       56
       56
       +
       		}

     

       57
       57
       +
       	}

     

       58
       58
       +
       

     

       59
       59
       +
       	count, _ := ix.indexer.DocCount()

     

       60
       60
       +
       	l.Info("Initialized the pull indexer", "docCount", count)

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       func generatePullIndexMapping() (mapping.IndexMapping, error) {

     

       64
       64
       +
       	mapping := bleve.NewIndexMapping()

     

       65
       65
       +
       	docMapping := bleve.NewDocumentMapping()

     

       66
       66
       +
       

     

       67
       67
       +
       	textFieldMapping := bleve.NewTextFieldMapping()

     

       68
       68
       +
       	textFieldMapping.Store = false

     

       69
       69
       +
       	textFieldMapping.IncludeInAll = false

     

       70
       70
       +
       

     

       71
       71
       +
       	keywordFieldMapping := bleve.NewKeywordFieldMapping()

     

       72
       72
       +
       	keywordFieldMapping.Store = false

     

       73
       73
       +
       	keywordFieldMapping.IncludeInAll = false

     

       74
       74
       +
       

     

       75
       75
       +
       	// numericFieldMapping := bleve.NewNumericFieldMapping()

     

       76
       76
       +
       

     

       77
       77
       +
       	docMapping.AddFieldMappingsAt("title", textFieldMapping)

     

       78
       78
       +
       	docMapping.AddFieldMappingsAt("body", textFieldMapping)

     

       79
       79
       +
       

     

       80
       80
       +
       	docMapping.AddFieldMappingsAt("repo_at", keywordFieldMapping)

     

       81
       81
       +
       	docMapping.AddFieldMappingsAt("state", keywordFieldMapping)

     

       82
       82
       +
       

     

       83
       83
       +
       	err := mapping.AddCustomTokenFilter(unicodeNormalizeName, map[string]any{

     

       84
       84
       +
       		"type": unicodenorm.Name,

     

       85
       85
       +
       		"form": unicodenorm.NFC,

     

       86
       86
       +
       	})

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return nil, err

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	err = mapping.AddCustomAnalyzer(pullIndexerAnalyzer, map[string]any{

     

       92
       92
       +
       		"type":          custom.Name,

     

       93
       93
       +
       		"char_filters":  []string{},

     

       94
       94
       +
       		"tokenizer":     unicode.Name,

     

       95
       95
       +
       		"token_filters": []string{unicodeNormalizeName, camelcase.Name, lowercase.Name},

     

       96
       96
       +
       	})

     

       97
       97
       +
       	if err != nil {

     

       98
       98
       +
       		return nil, err

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	mapping.DefaultAnalyzer = pullIndexerAnalyzer

     

       102
       102
       +
       	mapping.AddDocumentMapping(pullIndexerDocType, docMapping)

     

       103
       103
       +
       	mapping.AddDocumentMapping("_all", bleve.NewDocumentDisabledMapping())

     

       104
       104
       +
       	mapping.DefaultMapping = bleve.NewDocumentDisabledMapping()

     

       105
       105
       +
       

     

       106
       106
       +
       	return mapping, nil

     

       107
       107
       +
       }

     

       108
       108
       +
       

     

       109
       109
       +
       func (ix *Indexer) intialize(ctx context.Context) (bool, error) {

     

       110
       110
       +
       	if ix.indexer != nil {

     

       111
       111
       +
       		return false, errors.New("indexer is already initialized")

     

       112
       112
       +
       	}

     

       113
       113
       +
       

     

       114
       114
       +
       	indexer, err := openIndexer(ctx, ix.path)

     

       115
       115
       +
       	if err != nil {

     

       116
       116
       +
       		return false, err

     

       117
       117
       +
       	}

     

       118
       118
       +
       	if indexer != nil {

     

       119
       119
       +
       		ix.indexer = indexer

     

       120
       120
       +
       		return true, nil

     

       121
       121
       +
       	}

     

       122
       122
       +
       

     

       123
       123
       +
       	mapping, err := generatePullIndexMapping()

     

       124
       124
       +
       	if err != nil {

     

       125
       125
       +
       		return false, err

     

       126
       126
       +
       	}

     

       127
       127
       +
       	indexer, err = bleve.New(ix.path, mapping)

     

       128
       128
       +
       	if err != nil {

     

       129
       129
       +
       		return false, err

     

       130
       130
       +
       	}

     

       131
       131
       +
       

     

       132
       132
       +
       	ix.indexer = indexer

     

       133
       133
       +
       

     

       134
       134
       +
       	return false, nil

     

       135
       135
       +
       }

     

       136
       136
       +
       

     

       137
       137
       +
       func openIndexer(ctx context.Context, path string) (bleve.Index, error) {

     

       138
       138
       +
       	l := tlog.FromContext(ctx)

     

       139
       139
       +
       	indexer, err := bleve.Open(path)

     

       140
       140
       +
       	if err != nil {

     

       141
       141
       +
       		if errors.Is(err, upsidedown.IncompatibleVersion) {

     

       142
       142
       +
       			l.Info("Indexer was built with a previous version of bleve, deleting and rebuilding")

     

       143
       143
       +
       			return nil, os.RemoveAll(path)

     

       144
       144
       +
       		}

     

       145
       145
       +
       		return nil, nil

     

       146
       146
       +
       	}

     

       147
       147
       +
       	return indexer, nil

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       func PopulateIndexer(ctx context.Context, ix *Indexer, e db.Execer) error {

     

       151
       151
       +
       	l := tlog.FromContext(ctx)

     

       152
       152
       +
       

     

       153
       153
       +
       	pulls, err := db.GetPulls(e)

     

       154
       154
       +
       	if err != nil {

     

       155
       155
       +
       		return err

     

       156
       156
       +
       	}

     

       157
       157
       +
       	count := len(pulls)

     

       158
       158
       +
       	err = ix.Index(ctx, pulls...)

     

       159
       159
       +
       	if err != nil {

     

       160
       160
       +
       		return err

     

       161
       161
       +
       	}

     

       162
       162
       +
       	l.Info("pulls indexed", "count", count)

     

       163
       163
       +
       	return err

     

       164
       164
       +
       }

     

       165
       165
       +
       

     

       166
       166
       +
       // pullData data stored and will be indexed

     

       167
       167
       +
       type pullData struct {

     

       168
       168
       +
       	ID     int64  `json:"id"`

     

       169
       169
       +
       	RepoAt string `json:"repo_at"`

     

       170
       170
       +
       	PullID int    `json:"pull_id"`

     

       171
       171
       +
       	Title  string `json:"title"`

     

       172
       172
       +
       	Body   string `json:"body"`

     

       173
       173
       +
       	State  string `json:"state"`

     

       174
       174
       +
       

     

       175
       175
       +
       	Comments []pullCommentData `json:"comments"`

     

       176
       176
       +
       }

     

       177
       177
       +
       

     

       178
       178
       +
       func makePullData(pull *models.Pull) *pullData {

     

       179
       179
       +
       	return &pullData{

     

       180
       180
       +
       		ID:     int64(pull.ID),

     

       181
       181
       +
       		RepoAt: pull.RepoAt.String(),

     

       182
       182
       +
       		PullID: pull.PullId,

     

       183
       183
       +
       		Title:  pull.Title,

     

       184
       184
       +
       		Body:   pull.Body,

     

       185
       185
       +
       		State:  pull.State.String(),

     

       186
       186
       +
       	}

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       189
       189
       +
       // Type returns the document type, for bleve's mapping.Classifier interface.

     

       190
       190
       +
       func (i *pullData) Type() string {

     

       191
       191
       +
       	return pullIndexerDocType

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       type pullCommentData struct {

     

       195
       195
       +
       	Body string `json:"body"`

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       type searchResult struct {

     

       199
       199
       +
       	Hits  []int64

     

       200
       200
       +
       	Total uint64

     

       201
       201
       +
       }

     

       202
       202
       +
       

     

       203
       203
       +
       const maxBatchSize = 20

     

       204
       204
       +
       

     

       205
       205
       +
       func (ix *Indexer) Index(ctx context.Context, pulls ...*models.Pull) error {

     

       206
       206
       +
       	batch := bleveutil.NewFlushingBatch(ix.indexer, maxBatchSize)

     

       207
       207
       +
       	for _, pull := range pulls {

     

       208
       208
       +
       		pullData := makePullData(pull)

     

       209
       209
       +
       		if err := batch.Index(base36.Encode(pullData.ID), pullData); err != nil {

     

       210
       210
       +
       			return err

     

       211
       211
       +
       		}

     

       212
       212
       +
       	}

     

       213
       213
       +
       	return batch.Flush()

     

       214
       214
       +
       }

     

       215
       215
       +
       

     

       216
       216
       +
       func (ix *Indexer) Delete(ctx context.Context, pullID int64) error {

     

       217
       217
       +
       	return ix.indexer.Delete(base36.Encode(pullID))

     

       218
       218
       +
       }

     

       219
       219
       +
       

     

       220
       220
       +
       // Search searches for pulls

     

       221
       221
       +
       func (ix *Indexer) Search(ctx context.Context, opts models.PullSearchOptions) (*searchResult, error) {

     

       222
       222
       +
       	var queries []query.Query

     

       223
       223
       +
       

     

       224
       224
       +
       	// TODO(boltless): remove this after implementing pulls page pagination

     

       225
       225
       +
       	limit := opts.Page.Limit

     

       226
       226
       +
       	if limit == 0 {

     

       227
       227
       +
       		limit = 500

     

       228
       228
       +
       	}

     

       229
       229
       +
       

     

       230
       230
       +
       	if opts.Keyword != "" {

     

       231
       231
       +
       		queries = append(queries, bleve.NewDisjunctionQuery(

     

       232
       232
       +
       			bleveutil.MatchAndQuery("title", opts.Keyword, pullIndexerAnalyzer, 0),

     

       233
       233
       +
       			bleveutil.MatchAndQuery("body", opts.Keyword, pullIndexerAnalyzer, 0),

     

       234
       234
       +
       		))

     

       235
       235
       +
       	}

     

       236
       236
       +
       	queries = append(queries, bleveutil.KeywordFieldQuery("repo_at", opts.RepoAt))

     

       237
       237
       +
       	queries = append(queries, bleveutil.KeywordFieldQuery("state", opts.State.String()))

     

       238
       238
       +
       

     

       239
       239
       +
       	var indexerQuery query.Query = bleve.NewConjunctionQuery(queries...)

     

       240
       240
       +
       	searchReq := bleve.NewSearchRequestOptions(indexerQuery, limit, opts.Page.Offset, false)

     

       241
       241
       +
       	res, err := ix.indexer.SearchInContext(ctx, searchReq)

     

       242
       242
       +
       	if err != nil {

     

       243
       243
       +
       		return nil, nil

     

       244
       244
       +
       	}

     

       245
       245
       +
       	ret := &searchResult{

     

       246
       246
       +
       		Total: res.Total,

     

       247
       247
       +
       		Hits:  make([]int64, len(res.Hits)),

     

       248
       248
       +
       	}

     

       249
       249
       +
       	for i, hit := range res.Hits {

     

       250
       250
       +
       		id, err := base36.Decode(hit.ID)

     

       251
       251
       +
       		if err != nil {

     

       252
       252
       +
       			return nil, err

     

       253
       253
       +
       		}

     

       254
       254
       +
       		ret.Hits[i] = id

     

       255
       255
       +
       	}

     

       256
       256
       +
       	return ret, nil

     

       257
       257
       +
       }

+56 -32

appview/ingester.go

···

       21
       21
        
       	"tangled.org/core/appview/serververify"

     

       22
       22
        
       	"tangled.org/core/appview/validator"

     

       23
       23
        
       	"tangled.org/core/idresolver"

     

       24
       24
       +
       	"tangled.org/core/orm"

     

       24
       25
        
       	"tangled.org/core/rbac"

     

       25
       26
        
       )

     

       26
       27
        
       

     
···

       121
       122
        
       			return err

     

       122
       123
        
       		}

     

       123
       124
        
       		err = db.AddStar(i.Db, &models.Star{

     

       124
       124
       -
       			StarredByDid: did,

     

       125
       125
       -
       			RepoAt:       subjectUri,

     

       126
       126
       -
       			Rkey:         e.Commit.RKey,

     

       125
       125
       +
       			Did:    did,

     

       126
       126
       +
       			RepoAt: subjectUri,

     

       127
       127
       +
       			Rkey:   e.Commit.RKey,

     

       127
       128
        
       		})

     

       128
       129
        
       	case jmodels.CommitOperationDelete:

     

       129
       130
        
       		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)

     
···

       253
       254
        
       

     

       254
       255
        
       		err = db.AddArtifact(i.Db, artifact)

     

       255
       256
        
       	case jmodels.CommitOperationDelete:

     

       256
       256
       -
       		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       257
       257
       +
       		err = db.DeleteArtifact(i.Db, orm.FilterEq("did", did), orm.FilterEq("rkey", e.Commit.RKey))

     

       257
       258
        
       	}

     

       258
       259
        
       

     

       259
       260
        
       	if err != nil {

     
···

       291
       292
        
       

     

       292
       293
        
       		includeBluesky := record.Bluesky

     

       293
       294
        
       

     

       295
       295
       +
       		pronouns := ""

     

       296
       296
       +
       		if record.Pronouns != nil {

     

       297
       297
       +
       			pronouns = *record.Pronouns

     

       298
       298
       +
       		}

     

       299
       299
       +
       

     

       294
       300
        
       		location := ""

     

       295
       301
        
       		if record.Location != nil {

     

       296
       302
        
       			location = *record.Location

     
···

       325
       331
        
       			Links:          links,

     

       326
       332
        
       			Stats:          stats,

     

       327
       333
        
       			PinnedRepos:    pinned,

     

       334
       334
       +
       			Pronouns:       pronouns,

     

       328
       335
        
       		}

     

       329
       336
        
       

     

       330
       337
        
       		ddb, ok := i.Db.Execer.(*db.DB)

     
···

       344
       351
        
       

     

       345
       352
        
       		err = db.UpsertProfile(tx, &profile)

     

       346
       353
        
       	case jmodels.CommitOperationDelete:

     

       347
       347
       -
       		err = db.DeleteArtifact(i.Db, db.FilterEq("did", did), db.FilterEq("rkey", e.Commit.RKey))

     

       354
       354
       +
       		err = db.DeleteArtifact(i.Db, orm.FilterEq("did", did), orm.FilterEq("rkey", e.Commit.RKey))

     

       348
       355
        
       	}

     

       349
       356
        
       

     

       350
       357
        
       	if err != nil {

     
···

       418
       425
        
       		// get record from db first

     

       419
       426
        
       		members, err := db.GetSpindleMembers(

     

       420
       427
        
       			ddb,

     

       421
       421
       -
       			db.FilterEq("did", did),

     

       422
       422
       -
       			db.FilterEq("rkey", rkey),

     

       428
       428
       +
       			orm.FilterEq("did", did),

     

       429
       429
       +
       			orm.FilterEq("rkey", rkey),

     

       423
       430
        
       		)

     

       424
       431
        
       		if err != nil || len(members) != 1 {

     

       425
       432
        
       			return fmt.Errorf("failed to get member: %w, len(members) = %d", err, len(members))

     
···

       434
       441
        
       		// remove record by rkey && update enforcer

     

       435
       442
        
       		if err = db.RemoveSpindleMember(

     

       436
       443
        
       			tx,

     

       437
       437
       -
       			db.FilterEq("did", did),

     

       438
       438
       -
       			db.FilterEq("rkey", rkey),

     

       444
       444
       +
       			orm.FilterEq("did", did),

     

       445
       445
       +
       			orm.FilterEq("rkey", rkey),

     

       439
       446
        
       		); err != nil {

     

       440
       447
        
       			return fmt.Errorf("failed to remove from db: %w", err)

     

       441
       448
        
       		}

     
···

       517
       524
        
       		// get record from db first

     

       518
       525
        
       		spindles, err := db.GetSpindles(

     

       519
       526
        
       			ddb,

     

       520
       520
       -
       			db.FilterEq("owner", did),

     

       521
       521
       -
       			db.FilterEq("instance", instance),

     

       527
       527
       +
       			orm.FilterEq("owner", did),

     

       528
       528
       +
       			orm.FilterEq("instance", instance),

     

       522
       529
        
       		)

     

       523
       530
        
       		if err != nil || len(spindles) != 1 {

     

       524
       531
        
       			return fmt.Errorf("failed to get spindles: %w, len(spindles) = %d", err, len(spindles))

     
···

       537
       544
        
       		// remove spindle members first

     

       538
       545
        
       		err = db.RemoveSpindleMember(

     

       539
       546
        
       			tx,

     

       540
       540
       -
       			db.FilterEq("owner", did),

     

       541
       541
       -
       			db.FilterEq("instance", instance),

     

       547
       547
       +
       			orm.FilterEq("owner", did),

     

       548
       548
       +
       			orm.FilterEq("instance", instance),

     

       542
       549
        
       		)

     

       543
       550
        
       		if err != nil {

     

       544
       551
        
       			return err

     
···

       546
       553
        
       

     

       547
       554
        
       		err = db.DeleteSpindle(

     

       548
       555
        
       			tx,

     

       549
       549
       -
       			db.FilterEq("owner", did),

     

       550
       550
       -
       			db.FilterEq("instance", instance),

     

       556
       556
       +
       			orm.FilterEq("owner", did),

     

       557
       557
       +
       			orm.FilterEq("instance", instance),

     

       551
       558
        
       		)

     

       552
       559
        
       		if err != nil {

     

       553
       560
        
       			return err

     
···

       615
       622
        
       	case jmodels.CommitOperationDelete:

     

       616
       623
        
       		if err := db.DeleteString(

     

       617
       624
        
       			ddb,

     

       618
       618
       -
       			db.FilterEq("did", did),

     

       619
       619
       -
       			db.FilterEq("rkey", rkey),

     

       625
       625
       +
       			orm.FilterEq("did", did),

     

       626
       626
       +
       			orm.FilterEq("rkey", rkey),

     

       620
       627
        
       		); err != nil {

     

       621
       628
        
       			l.Error("failed to delete", "err", err)

     

       622
       629
        
       			return fmt.Errorf("failed to delete string record: %w", err)

     
···

       734
       741
        
       		// get record from db first

     

       735
       742
        
       		registrations, err := db.GetRegistrations(

     

       736
       743
        
       			ddb,

     

       737
       737
       -
       			db.FilterEq("domain", domain),

     

       738
       738
       -
       			db.FilterEq("did", did),

     

       744
       744
       +
       			orm.FilterEq("domain", domain),

     

       745
       745
       +
       			orm.FilterEq("did", did),

     

       739
       746
        
       		)

     

       740
       747
        
       		if err != nil {

     

       741
       748
        
       			return fmt.Errorf("failed to get registration: %w", err)

     
···

       756
       763
        
       

     

       757
       764
        
       		err = db.DeleteKnot(

     

       758
       765
        
       			tx,

     

       759
       759
       -
       			db.FilterEq("did", did),

     

       760
       760
       -
       			db.FilterEq("domain", domain),

     

       766
       766
       +
       			orm.FilterEq("did", did),

     

       767
       767
       +
       			orm.FilterEq("domain", domain),

     

       761
       768
        
       		)

     

       762
       769
        
       		if err != nil {

     

       763
       770
        
       			return err

     
···

       835
       842
        
       		return nil

     

       836
       843
        
       

     

       837
       844
        
       	case jmodels.CommitOperationDelete:

     

       845
       845
       +
       		tx, err := ddb.BeginTx(ctx, nil)

     

       846
       846
       +
       		if err != nil {

     

       847
       847
       +
       			l.Error("failed to begin transaction", "err", err)

     

       848
       848
       +
       			return err

     

       849
       849
       +
       		}

     

       850
       850
       +
       		defer tx.Rollback()

     

       851
       851
       +
       

     

       838
       852
        
       		if err := db.DeleteIssues(

     

       839
       839
       -
       			ddb,

     

       840
       840
       -
       			db.FilterEq("did", did),

     

       841
       841
       -
       			db.FilterEq("rkey", rkey),

     

       853
       853
       +
       			tx,

     

       854
       854
       +
       			did,

     

       855
       855
       +
       			rkey,

     

       842
       856
        
       		); err != nil {

     

       843
       857
        
       			l.Error("failed to delete", "err", err)

     

       844
       858
        
       			return fmt.Errorf("failed to delete issue record: %w", err)

     

       859
       859
       +
       		}

     

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

     

       861
       861
       +
       			l.Error("failed to commit txn", "err", err)

     

       862
       862
       +
       			return err

     

       845
       863
        
       		}

     

       846
       864
        
       

     

       847
       865
        
       		return nil

     
···

       882
       900
        
       			return fmt.Errorf("failed to validate comment: %w", err)

     

       883
       901
        
       		}

     

       884
       902
        
       

     

       885
       885
       -
       		_, err = db.AddIssueComment(ddb, *comment)

     

       903
       903
       +
       		tx, err := ddb.Begin()

     

       904
       904
       +
       		if err != nil {

     

       905
       905
       +
       			return fmt.Errorf("failed to start transaction: %w", err)

     

       906
       906
       +
       		}

     

       907
       907
       +
       		defer tx.Rollback()

     

       908
       908
       +
       

     

       909
       909
       +
       		_, err = db.AddIssueComment(tx, *comment)

     

       886
       910
        
       		if err != nil {

     

       887
       911
        
       			return fmt.Errorf("failed to create issue comment: %w", err)

     

       888
       912
        
       		}

     

       889
       913
        
       

     

       890
       890
       -
       		return nil

     

       914
       914
       +
       		return tx.Commit()

     

       891
       915
        
       

     

       892
       916
        
       	case jmodels.CommitOperationDelete:

     

       893
       917
        
       		if err := db.DeleteIssueComments(

     

       894
       918
        
       			ddb,

     

       895
       895
       -
       			db.FilterEq("did", did),

     

       896
       896
       -
       			db.FilterEq("rkey", rkey),

     

       919
       919
       +
       			orm.FilterEq("did", did),

     

       920
       920
       +
       			orm.FilterEq("rkey", rkey),

     

       897
       921
        
       		); err != nil {

     

       898
       922
        
       			return fmt.Errorf("failed to delete issue comment record: %w", err)

     

       899
       923
        
       		}

     
···

       946
       970
        
       	case jmodels.CommitOperationDelete:

     

       947
       971
        
       		if err := db.DeleteLabelDefinition(

     

       948
       972
        
       			ddb,

     

       949
       949
       -
       			db.FilterEq("did", did),

     

       950
       950
       -
       			db.FilterEq("rkey", rkey),

     

       973
       973
       +
       			orm.FilterEq("did", did),

     

       974
       974
       +
       			orm.FilterEq("rkey", rkey),

     

       951
       975
        
       		); err != nil {

     

       952
       976
        
       			return fmt.Errorf("failed to delete labeldef record: %w", err)

     

       953
       977
        
       		}

     
···

       987
       1011
        
       		var repo *models.Repo

     

       988
       1012
        
       		switch collection {

     

       989
       1013
        
       		case tangled.RepoIssueNSID:

     

       990
       990
       -
       			i, err := db.GetIssues(ddb, db.FilterEq("at_uri", subject))

     

       1014
       1014
       +
       			i, err := db.GetIssues(ddb, orm.FilterEq("at_uri", subject))

     

       991
       1015
        
       			if err != nil || len(i) != 1 {

     

       992
       1016
        
       				return fmt.Errorf("failed to find subject: %w || subject count %d", err, len(i))

     

       993
       1017
        
       			}

     
···

       996
       1020
        
       			return fmt.Errorf("unsupport label subject: %s", collection)

     

       997
       1021
        
       		}

     

       998
       1022
        
       

     

       999
       999
       -
       		actx, err := db.NewLabelApplicationCtx(ddb, db.FilterIn("at_uri", repo.Labels))

     

       1023
       1023
       +
       		actx, err := db.NewLabelApplicationCtx(ddb, orm.FilterIn("at_uri", repo.Labels))

     

       1000
       1024
        
       		if err != nil {

     

       1001
       1025
        
       			return fmt.Errorf("failed to build label application ctx: %w", err)

     

       1002
       1026
        
       		}

+209 -130

appview/issues/issues.go

···

       7
       7
        
       	"fmt"

     

       8
       8
        
       	"log/slog"

     

       9
       9
        
       	"net/http"

     

       10
       10
       -
       	"slices"

     

       11
       10
        
       	"time"

     

       12
       11
        
       

     

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

     
···

       19
       18
        
       	"tangled.org/core/api/tangled"

     

       20
       19
        
       	"tangled.org/core/appview/config"

     

       21
       20
        
       	"tangled.org/core/appview/db"

     

       21
       21
       +
       	issues_indexer "tangled.org/core/appview/indexer/issues"

     

       22
       22
       +
       	"tangled.org/core/appview/mentions"

     

       22
       23
        
       	"tangled.org/core/appview/models"

     

       23
       24
        
       	"tangled.org/core/appview/notify"

     

       24
       25
        
       	"tangled.org/core/appview/oauth"

     

       25
       26
        
       	"tangled.org/core/appview/pages"

     

       27
       27
       +
       	"tangled.org/core/appview/pages/repoinfo"

     

       26
       28
        
       	"tangled.org/core/appview/pagination"

     

       27
       29
        
       	"tangled.org/core/appview/reporesolver"

     

       28
       30
        
       	"tangled.org/core/appview/validator"

     

       29
       31
        
       	"tangled.org/core/idresolver"

     

       32
       32
       +
       	"tangled.org/core/orm"

     

       33
       33
       +
       	"tangled.org/core/rbac"

     

       30
       34
        
       	"tangled.org/core/tid"

     

       31
       35
        
       )

     

       32
       36
        
       

     

       33
       37
        
       type Issues struct {

     

       34
       34
       -
       	oauth        *oauth.OAuth

     

       35
       35
       -
       	repoResolver *reporesolver.RepoResolver

     

       36
       36
       -
       	pages        *pages.Pages

     

       37
       37
       -
       	idResolver   *idresolver.Resolver

     

       38
       38
       -
       	db           *db.DB

     

       39
       39
       -
       	config       *config.Config

     

       40
       40
       -
       	notifier     notify.Notifier

     

       41
       41
       -
       	logger       *slog.Logger

     

       42
       42
       -
       	validator    *validator.Validator

     

       38
       38
       +
       	oauth            *oauth.OAuth

     

       39
       39
       +
       	repoResolver     *reporesolver.RepoResolver

     

       40
       40
       +
       	enforcer         *rbac.Enforcer

     

       41
       41
       +
       	pages            *pages.Pages

     

       42
       42
       +
       	idResolver       *idresolver.Resolver

     

       43
       43
       +
       	mentionsResolver *mentions.Resolver

     

       44
       44
       +
       	db               *db.DB

     

       45
       45
       +
       	config           *config.Config

     

       46
       46
       +
       	notifier         notify.Notifier

     

       47
       47
       +
       	logger           *slog.Logger

     

       48
       48
       +
       	validator        *validator.Validator

     

       49
       49
       +
       	indexer          *issues_indexer.Indexer

     

       43
       50
        
       }

     

       44
       51
        
       

     

       45
       52
        
       func New(

     

       46
       53
        
       	oauth *oauth.OAuth,

     

       47
       54
        
       	repoResolver *reporesolver.RepoResolver,

     

       55
       55
       +
       	enforcer *rbac.Enforcer,

     

       48
       56
        
       	pages *pages.Pages,

     

       49
       57
        
       	idResolver *idresolver.Resolver,

     

       58
       58
       +
       	mentionsResolver *mentions.Resolver,

     

       50
       59
        
       	db *db.DB,

     

       51
       60
        
       	config *config.Config,

     

       52
       61
        
       	notifier notify.Notifier,

     

       53
       62
        
       	validator *validator.Validator,

     

       63
       63
       +
       	indexer *issues_indexer.Indexer,

     

       54
       64
        
       	logger *slog.Logger,

     

       55
       65
        
       ) *Issues {

     

       56
       66
        
       	return &Issues{

     

       57
       57
       -
       		oauth:        oauth,

     

       58
       58
       -
       		repoResolver: repoResolver,

     

       59
       59
       -
       		pages:        pages,

     

       60
       60
       -
       		idResolver:   idResolver,

     

       61
       61
       -
       		db:           db,

     

       62
       62
       -
       		config:       config,

     

       63
       63
       -
       		notifier:     notifier,

     

       64
       64
       -
       		logger:       logger,

     

       65
       65
       -
       		validator:    validator,

     

       67
       67
       +
       		oauth:            oauth,

     

       68
       68
       +
       		repoResolver:     repoResolver,

     

       69
       69
       +
       		enforcer:         enforcer,

     

       70
       70
       +
       		pages:            pages,

     

       71
       71
       +
       		idResolver:       idResolver,

     

       72
       72
       +
       		mentionsResolver: mentionsResolver,

     

       73
       73
       +
       		db:               db,

     

       74
       74
       +
       		config:           config,

     

       75
       75
       +
       		notifier:         notifier,

     

       76
       76
       +
       		logger:           logger,

     

       77
       77
       +
       		validator:        validator,

     

       78
       78
       +
       		indexer:          indexer,

     

       66
       79
        
       	}

     

       67
       80
        
       }

     

       68
       81
        
       

     
···

       92
       105
        
       		userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri())

     

       93
       106
        
       	}

     

       94
       107
        
       

     

       108
       108
       +
       	backlinks, err := db.GetBacklinks(rp.db, issue.AtUri())

     

       109
       109
       +
       	if err != nil {

     

       110
       110
       +
       		l.Error("failed to fetch backlinks", "err", err)

     

       111
       111
       +
       		rp.pages.Error503(w)

     

       112
       112
       +
       		return

     

       113
       113
       +
       	}

     

       114
       114
       +
       

     

       95
       115
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       96
       116
        
       		rp.db,

     

       97
       97
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       98
       98
       -
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       117
       117
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       118
       118
       +
       		orm.FilterContains("scope", tangled.RepoIssueNSID),

     

       99
       119
        
       	)

     

       100
       120
        
       	if err != nil {

     

       101
       121
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       110
       130
        
       

     

       111
       131
        
       	rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{

     

       112
       132
        
       		LoggedInUser:         user,

     

       113
       113
       -
       		RepoInfo:             f.RepoInfo(user),

     

       133
       133
       +
       		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       114
       134
        
       		Issue:                issue,

     

       115
       135
        
       		CommentList:          issue.CommentList(),

     

       136
       136
       +
       		Backlinks:            backlinks,

     

       116
       137
        
       		OrderedReactionKinds: models.OrderedReactionKinds,

     

       117
       138
        
       		Reactions:            reactionMap,

     

       118
       139
        
       		UserReacted:          userReactions,

     
···

       123
       144
        
       func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) {

     

       124
       145
        
       	l := rp.logger.With("handler", "EditIssue")

     

       125
       146
        
       	user := rp.oauth.GetUser(r)

     

       126
       126
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       127
       127
       -
       	if err != nil {

     

       128
       128
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       129
       129
       -
       		return

     

       130
       130
       -
       	}

     

       131
       147
        
       

     

       132
       148
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       133
       149
        
       	if !ok {

     
···

       140
       156
        
       	case http.MethodGet:

     

       141
       157
        
       		rp.pages.EditIssueFragment(w, pages.EditIssueParams{

     

       142
       158
        
       			LoggedInUser: user,

     

       143
       143
       -
       			RepoInfo:     f.RepoInfo(user),

     

       159
       159
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       144
       160
        
       			Issue:        issue,

     

       145
       161
        
       		})

     

       146
       162
        
       	case http.MethodPost:

     
···

       148
       164
        
       		newIssue := issue

     

       149
       165
        
       		newIssue.Title = r.FormValue("title")

     

       150
       166
        
       		newIssue.Body = r.FormValue("body")

     

       167
       167
       +
       		newIssue.Mentions, newIssue.References = rp.mentionsResolver.Resolve(r.Context(), newIssue.Body)

     

       151
       168
        
       

     

       152
       169
        
       		if err := rp.validator.ValidateIssue(newIssue); err != nil {

     

       153
       170
        
       			l.Error("validation error", "err", err)

     
···

       216
       233
        
       func (rp *Issues) DeleteIssue(w http.ResponseWriter, r *http.Request) {

     

       217
       234
        
       	l := rp.logger.With("handler", "DeleteIssue")

     

       218
       235
        
       	noticeId := "issue-actions-error"

     

       219
       219
       -
       

     

       220
       220
       -
       	user := rp.oauth.GetUser(r)

     

       221
       236
        
       

     

       222
       237
        
       	f, err := rp.repoResolver.Resolve(r)

     

       223
       238
        
       	if err != nil {

     
···

       233
       248
        
       	}

     

       234
       249
        
       	l = l.With("did", issue.Did, "rkey", issue.Rkey)

     

       235
       250
        
       

     

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

     

       252
       252
       +
       	if err != nil {

     

       253
       253
       +
       		l.Error("failed to start transaction", "err", err)

     

       254
       254
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       255
       255
       +
       		return

     

       256
       256
       +
       	}

     

       257
       257
       +
       	defer tx.Rollback()

     

       258
       258
       +
       

     

       236
       259
        
       	// delete from PDS

     

       237
       260
        
       	client, err := rp.oauth.AuthorizedClient(r)

     

       238
       261
        
       	if err != nil {

     
···

       253
       276
        
       	}

     

       254
       277
        
       

     

       255
       278
        
       	// delete from db

     

       256
       256
       -
       	if err := db.DeleteIssues(rp.db, db.FilterEq("id", issue.Id)); err != nil {

     

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

     

       257
       280
        
       		l.Error("failed to delete issue", "err", err)

     

       258
       281
        
       		rp.pages.Notice(w, noticeId, "Failed to delete issue.")

     

       259
       282
        
       		return

     

       260
       283
        
       	}

     

       284
       284
       +
       	tx.Commit()

     

       285
       285
       +
       

     

       286
       286
       +
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       261
       287
        
       

     

       262
       288
        
       	// return to all issues page

     

       263
       263
       -
       	rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues")

     

       289
       289
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       290
       290
       +
       	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")

     

       264
       291
        
       }

     

       265
       292
        
       

     

       266
       293
        
       func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {

     
···

       279
       306
        
       		return

     

       280
       307
        
       	}

     

       281
       308
        
       

     

       282
       282
       -
       	collaborators, err := f.Collaborators(r.Context())

     

       283
       283
       -
       	if err != nil {

     

       284
       284
       -
       		l.Error("failed to fetch repo collaborators", "err", err)

     

       285
       285
       -
       	}

     

       286
       286
       -
       	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       287
       287
       -
       		return user.Did == collab.Did

     

       288
       288
       -
       	})

     

       309
       309
       +
       	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       310
       310
       +
       	isRepoOwner := roles.IsOwner()

     

       311
       311
       +
       	isCollaborator := roles.IsCollaborator()

     

       289
       312
        
       	isIssueOwner := user.Did == issue.Did

     

       290
       313
        
       

     

       291
       314
        
       	// TODO: make this more granular

     

       292
       292
       -
       	if isIssueOwner || isCollaborator {

     

       315
       315
       +
       	if isIssueOwner || isRepoOwner || isCollaborator {

     

       293
       316
        
       		err = db.CloseIssues(

     

       294
       317
        
       			rp.db,

     

       295
       295
       -
       			db.FilterEq("id", issue.Id),

     

       318
       318
       +
       			orm.FilterEq("id", issue.Id),

     

       296
       319
        
       		)

     

       297
       320
        
       		if err != nil {

     

       298
       321
        
       			l.Error("failed to close issue", "err", err)

     

       299
       322
        
       			rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")

     

       300
       323
        
       			return

     

       301
       324
        
       		}

     

       325
       325
       +
       		// change the issue state (this will pass down to the notifiers)

     

       326
       326
       +
       		issue.Open = false

     

       302
       327
        
       

     

       303
       328
        
       		// notify about the issue closure

     

       304
       304
       -
       		rp.notifier.NewIssueClosed(r.Context(), issue)

     

       329
       329
       +
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       305
       330
        
       

     

       306
       306
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       331
       331
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       332
       332
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       307
       333
        
       		return

     

       308
       334
        
       	} else {

     

       309
       335
        
       		l.Error("user is not permitted to close issue")

     
···

       328
       354
        
       		return

     

       329
       355
        
       	}

     

       330
       356
        
       

     

       331
       331
       -
       	collaborators, err := f.Collaborators(r.Context())

     

       332
       332
       -
       	if err != nil {

     

       333
       333
       -
       		l.Error("failed to fetch repo collaborators", "err", err)

     

       334
       334
       -
       	}

     

       335
       335
       -
       	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       336
       336
       -
       		return user.Did == collab.Did

     

       337
       337
       -
       	})

     

       357
       357
       +
       	roles := repoinfo.RolesInRepo{Roles: rp.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       358
       358
       +
       	isRepoOwner := roles.IsOwner()

     

       359
       359
       +
       	isCollaborator := roles.IsCollaborator()

     

       338
       360
        
       	isIssueOwner := user.Did == issue.Did

     

       339
       361
        
       

     

       340
       340
       -
       	if isCollaborator || isIssueOwner {

     

       362
       362
       +
       	if isCollaborator || isRepoOwner || isIssueOwner {

     

       341
       363
        
       		err := db.ReopenIssues(

     

       342
       364
        
       			rp.db,

     

       343
       343
       -
       			db.FilterEq("id", issue.Id),

     

       365
       365
       +
       			orm.FilterEq("id", issue.Id),

     

       344
       366
        
       		)

     

       345
       367
        
       		if err != nil {

     

       346
       368
        
       			l.Error("failed to reopen issue", "err", err)

     

       347
       369
        
       			rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")

     

       348
       370
        
       			return

     

       349
       371
        
       		}

     

       350
       350
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       372
       372
       +
       		// change the issue state (this will pass down to the notifiers)

     

       373
       373
       +
       		issue.Open = true

     

       374
       374
       +
       

     

       375
       375
       +
       		// notify about the issue reopen

     

       376
       376
       +
       		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)

     

       377
       377
       +
       

     

       378
       378
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       379
       379
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       351
       380
        
       		return

     

       352
       381
        
       	} else {

     

       353
       382
        
       		l.Error("user is not the owner of the repo")

     
···

       384
       413
        
       		replyTo = &replyToUri

     

       385
       414
        
       	}

     

       386
       415
        
       

     

       416
       416
       +
       	mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)

     

       417
       417
       +
       

     

       387
       418
        
       	comment := models.IssueComment{

     

       388
       388
       -
       		Did:     user.Did,

     

       389
       389
       -
       		Rkey:    tid.TID(),

     

       390
       390
       -
       		IssueAt: issue.AtUri().String(),

     

       391
       391
       -
       		ReplyTo: replyTo,

     

       392
       392
       -
       		Body:    body,

     

       393
       393
       -
       		Created: time.Now(),

     

       419
       419
       +
       		Did:        user.Did,

     

       420
       420
       +
       		Rkey:       tid.TID(),

     

       421
       421
       +
       		IssueAt:    issue.AtUri().String(),

     

       422
       422
       +
       		ReplyTo:    replyTo,

     

       423
       423
       +
       		Body:       body,

     

       424
       424
       +
       		Created:    time.Now(),

     

       425
       425
       +
       		Mentions:   mentions,

     

       426
       426
       +
       		References: references,

     

       394
       427
        
       	}

     

       395
       428
        
       	if err = rp.validator.ValidateIssueComment(&comment); err != nil {

     

       396
       429
        
       		l.Error("failed to validate comment", "err", err)

     
···

       427
       460
        
       		}

     

       428
       461
        
       	}()

     

       429
       462
        
       

     

       430
       430
       -
       	commentId, err := db.AddIssueComment(rp.db, comment)

     

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

     

       464
       464
       +
       	if err != nil {

     

       465
       465
       +
       		l.Error("failed to start transaction", "err", err)

     

       466
       466
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       467
       467
       +
       		return

     

       468
       468
       +
       	}

     

       469
       469
       +
       	defer tx.Rollback()

     

       470
       470
       +
       

     

       471
       471
       +
       	commentId, err := db.AddIssueComment(tx, comment)

     

       431
       472
        
       	if err != nil {

     

       432
       473
        
       		l.Error("failed to create comment", "err", err)

     

       433
       474
        
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     

       434
       475
        
       		return

     

       435
       476
        
       	}

     

       477
       477
       +
       	err = tx.Commit()

     

       478
       478
       +
       	if err != nil {

     

       479
       479
       +
       		l.Error("failed to commit transaction", "err", err)

     

       480
       480
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       481
       481
       +
       		return

     

       482
       482
       +
       	}

     

       436
       483
        
       

     

       437
       484
        
       	// reset atUri to make rollback a no-op

     

       438
       485
        
       	atUri = ""

     

       439
       486
        
       

     

       440
       487
        
       	// notify about the new comment

     

       441
       488
        
       	comment.Id = commentId

     

       442
       442
       -
       	rp.notifier.NewIssueComment(r.Context(), &comment)

     

       489
       489
       +
       

     

       490
       490
       +
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       443
       491
        
       

     

       444
       444
       -
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId))

     

       492
       492
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       493
       493
       +
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       445
       494
        
       }

     

       446
       495
        
       

     

       447
       496
        
       func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {

     

       448
       497
        
       	l := rp.logger.With("handler", "IssueComment")

     

       449
       498
        
       	user := rp.oauth.GetUser(r)

     

       450
       450
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       451
       451
       -
       	if err != nil {

     

       452
       452
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       453
       453
       -
       		return

     

       454
       454
       -
       	}

     

       455
       499
        
       

     

       456
       500
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       457
       501
        
       	if !ok {

     
···

       463
       507
        
       	commentId := chi.URLParam(r, "commentId")

     

       464
       508
        
       	comments, err := db.GetIssueComments(

     

       465
       509
        
       		rp.db,

     

       466
       466
       -
       		db.FilterEq("id", commentId),

     

       510
       510
       +
       		orm.FilterEq("id", commentId),

     

       467
       511
        
       	)

     

       468
       512
        
       	if err != nil {

     

       469
       513
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       479
       523
        
       

     

       480
       524
        
       	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       481
       525
        
       		LoggedInUser: user,

     

       482
       482
       -
       		RepoInfo:     f.RepoInfo(user),

     

       526
       526
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       483
       527
        
       		Issue:        issue,

     

       484
       528
        
       		Comment:      &comment,

     

       485
       529
        
       	})

     
···

       488
       532
        
       func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) {

     

       489
       533
        
       	l := rp.logger.With("handler", "EditIssueComment")

     

       490
       534
        
       	user := rp.oauth.GetUser(r)

     

       491
       491
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       492
       492
       -
       	if err != nil {

     

       493
       493
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       494
       494
       -
       		return

     

       495
       495
       -
       	}

     

       496
       535
        
       

     

       497
       536
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       498
       537
        
       	if !ok {

     
···

       504
       543
        
       	commentId := chi.URLParam(r, "commentId")

     

       505
       544
        
       	comments, err := db.GetIssueComments(

     

       506
       545
        
       		rp.db,

     

       507
       507
       -
       		db.FilterEq("id", commentId),

     

       546
       546
       +
       		orm.FilterEq("id", commentId),

     

       508
       547
        
       	)

     

       509
       548
        
       	if err != nil {

     

       510
       549
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       528
       567
        
       	case http.MethodGet:

     

       529
       568
        
       		rp.pages.EditIssueCommentFragment(w, pages.EditIssueCommentParams{

     

       530
       569
        
       			LoggedInUser: user,

     

       531
       531
       -
       			RepoInfo:     f.RepoInfo(user),

     

       570
       570
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       532
       571
        
       			Issue:        issue,

     

       533
       572
        
       			Comment:      &comment,

     

       534
       573
        
       		})

     
···

       546
       585
        
       		newComment := comment

     

       547
       586
        
       		newComment.Body = newBody

     

       548
       587
        
       		newComment.Edited = &now

     

       588
       588
       +
       		newComment.Mentions, newComment.References = rp.mentionsResolver.Resolve(r.Context(), newBody)

     

       589
       589
       +
       

     

       549
       590
        
       		record := newComment.AsRecord()

     

       550
       591
        
       

     

       551
       551
       -
       		_, err = db.AddIssueComment(rp.db, newComment)

     

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

     

       593
       593
       +
       		if err != nil {

     

       594
       594
       +
       			l.Error("failed to start transaction", "err", err)

     

       595
       595
       +
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       596
       596
       +
       			return

     

       597
       597
       +
       		}

     

       598
       598
       +
       		defer tx.Rollback()

     

       599
       599
       +
       

     

       600
       600
       +
       		_, err = db.AddIssueComment(tx, newComment)

     

       552
       601
        
       		if err != nil {

     

       553
       602
        
       			l.Error("failed to perferom update-description query", "err", err)

     

       554
       603
        
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       555
       604
        
       			return

     

       556
       605
        
       		}

     

       606
       606
       +
       		tx.Commit()

     

       557
       607
        
       

     

       558
       608
        
       		// rkey is optional, it was introduced later

     

       559
       609
        
       		if newComment.Rkey != "" {

     
···

       582
       632
        
       		// return new comment body with htmx

     

       583
       633
        
       		rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       584
       634
        
       			LoggedInUser: user,

     

       585
       585
       -
       			RepoInfo:     f.RepoInfo(user),

     

       635
       635
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       586
       636
        
       			Issue:        issue,

     

       587
       637
        
       			Comment:      &newComment,

     

       588
       638
        
       		})

     
···

       592
       642
        
       func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) {

     

       593
       643
        
       	l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder")

     

       594
       644
        
       	user := rp.oauth.GetUser(r)

     

       595
       595
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       596
       596
       -
       	if err != nil {

     

       597
       597
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       598
       598
       -
       		return

     

       599
       599
       -
       	}

     

       600
       645
        
       

     

       601
       646
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       602
       647
        
       	if !ok {

     
···

       608
       653
        
       	commentId := chi.URLParam(r, "commentId")

     

       609
       654
        
       	comments, err := db.GetIssueComments(

     

       610
       655
        
       		rp.db,

     

       611
       611
       -
       		db.FilterEq("id", commentId),

     

       656
       656
       +
       		orm.FilterEq("id", commentId),

     

       612
       657
        
       	)

     

       613
       658
        
       	if err != nil {

     

       614
       659
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       624
       669
        
       

     

       625
       670
        
       	rp.pages.ReplyIssueCommentPlaceholderFragment(w, pages.ReplyIssueCommentPlaceholderParams{

     

       626
       671
        
       		LoggedInUser: user,

     

       627
       627
       -
       		RepoInfo:     f.RepoInfo(user),

     

       672
       672
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       628
       673
        
       		Issue:        issue,

     

       629
       674
        
       		Comment:      &comment,

     

       630
       675
        
       	})

     
···

       633
       678
        
       func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) {

     

       634
       679
        
       	l := rp.logger.With("handler", "ReplyIssueComment")

     

       635
       680
        
       	user := rp.oauth.GetUser(r)

     

       636
       636
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       637
       637
       -
       	if err != nil {

     

       638
       638
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       639
       639
       -
       		return

     

       640
       640
       -
       	}

     

       641
       681
        
       

     

       642
       682
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       643
       683
        
       	if !ok {

     
···

       649
       689
        
       	commentId := chi.URLParam(r, "commentId")

     

       650
       690
        
       	comments, err := db.GetIssueComments(

     

       651
       691
        
       		rp.db,

     

       652
       652
       -
       		db.FilterEq("id", commentId),

     

       692
       692
       +
       		orm.FilterEq("id", commentId),

     

       653
       693
        
       	)

     

       654
       694
        
       	if err != nil {

     

       655
       695
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       665
       705
        
       

     

       666
       706
        
       	rp.pages.ReplyIssueCommentFragment(w, pages.ReplyIssueCommentParams{

     

       667
       707
        
       		LoggedInUser: user,

     

       668
       668
       -
       		RepoInfo:     f.RepoInfo(user),

     

       708
       708
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       669
       709
        
       		Issue:        issue,

     

       670
       710
        
       		Comment:      &comment,

     

       671
       711
        
       	})

     
···

       674
       714
        
       func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {

     

       675
       715
        
       	l := rp.logger.With("handler", "DeleteIssueComment")

     

       676
       716
        
       	user := rp.oauth.GetUser(r)

     

       677
       677
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       678
       678
       -
       	if err != nil {

     

       679
       679
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       680
       680
       -
       		return

     

       681
       681
       -
       	}

     

       682
       717
        
       

     

       683
       718
        
       	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       684
       719
        
       	if !ok {

     
···

       690
       725
        
       	commentId := chi.URLParam(r, "commentId")

     

       691
       726
        
       	comments, err := db.GetIssueComments(

     

       692
       727
        
       		rp.db,

     

       693
       693
       -
       		db.FilterEq("id", commentId),

     

       728
       728
       +
       		orm.FilterEq("id", commentId),

     

       694
       729
        
       	)

     

       695
       730
        
       	if err != nil {

     

       696
       731
        
       		l.Error("failed to fetch comment", "id", commentId)

     
···

       717
       752
        
       

     

       718
       753
        
       	// optimistic deletion

     

       719
       754
        
       	deleted := time.Now()

     

       720
       720
       -
       	err = db.DeleteIssueComments(rp.db, db.FilterEq("id", comment.Id))

     

       755
       755
       +
       	err = db.DeleteIssueComments(rp.db, orm.FilterEq("id", comment.Id))

     

       721
       756
        
       	if err != nil {

     

       722
       757
        
       		l.Error("failed to delete comment", "err", err)

     

       723
       758
        
       		rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")

     
···

       749
       784
        
       	// htmx fragment of comment after deletion

     

       750
       785
        
       	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       751
       786
        
       		LoggedInUser: user,

     

       752
       752
       -
       		RepoInfo:     f.RepoInfo(user),

     

       787
       787
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       753
       788
        
       		Issue:        issue,

     

       754
       789
        
       		Comment:      &comment,

     

       755
       790
        
       	})

     
···

       770
       805
        
       		isOpen = true

     

       771
       806
        
       	}

     

       772
       807
        
       

     

       773
       773
       -
       	page, ok := r.Context().Value("page").(pagination.Page)

     

       774
       774
       -
       	if !ok {

     

       775
       775
       -
       		l.Error("failed to get page")

     

       776
       776
       -
       		page = pagination.FirstPage()

     

       777
       777
       -
       	}

     

       808
       808
       +
       	page := pagination.FromContext(r.Context())

     

       778
       809
        
       

     

       779
       810
        
       	user := rp.oauth.GetUser(r)

     

       780
       811
        
       	f, err := rp.repoResolver.Resolve(r)

     
···

       783
       814
        
       		return

     

       784
       815
        
       	}

     

       785
       816
        
       

     

       786
       786
       -
       	openVal := 0

     

       817
       817
       +
       	totalIssues := 0

     

       787
       818
        
       	if isOpen {

     

       788
       788
       -
       		openVal = 1

     

       819
       819
       +
       		totalIssues = f.RepoStats.IssueCount.Open

     

       820
       820
       +
       	} else {

     

       821
       821
       +
       		totalIssues = f.RepoStats.IssueCount.Closed

     

       822
       822
       +
       	}

     

       823
       823
       +
       

     

       824
       824
       +
       	keyword := params.Get("q")

     

       825
       825
       +
       

     

       826
       826
       +
       	var issues []models.Issue

     

       827
       827
       +
       	searchOpts := models.IssueSearchOptions{

     

       828
       828
       +
       		Keyword: keyword,

     

       829
       829
       +
       		RepoAt:  f.RepoAt().String(),

     

       830
       830
       +
       		IsOpen:  isOpen,

     

       831
       831
       +
       		Page:    page,

     

       789
       832
        
       	}

     

       790
       790
       -
       	issues, err := db.GetIssuesPaginated(

     

       791
       791
       -
       		rp.db,

     

       792
       792
       -
       		page,

     

       793
       793
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       794
       794
       -
       		db.FilterEq("open", openVal),

     

       795
       795
       -
       	)

     

       796
       796
       -
       	if err != nil {

     

       797
       797
       -
       		l.Error("failed to get issues", "err", err)

     

       798
       798
       -
       		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       799
       799
       -
       		return

     

       833
       833
       +
       	if keyword != "" {

     

       834
       834
       +
       		res, err := rp.indexer.Search(r.Context(), searchOpts)

     

       835
       835
       +
       		if err != nil {

     

       836
       836
       +
       			l.Error("failed to search for issues", "err", err)

     

       837
       837
       +
       			return

     

       838
       838
       +
       		}

     

       839
       839
       +
       		l.Debug("searched issues with indexer", "count", len(res.Hits))

     

       840
       840
       +
       		totalIssues = int(res.Total)

     

       841
       841
       +
       

     

       842
       842
       +
       		issues, err = db.GetIssues(

     

       843
       843
       +
       			rp.db,

     

       844
       844
       +
       			orm.FilterIn("id", res.Hits),

     

       845
       845
       +
       		)

     

       846
       846
       +
       		if err != nil {

     

       847
       847
       +
       			l.Error("failed to get issues", "err", err)

     

       848
       848
       +
       			rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       849
       849
       +
       			return

     

       850
       850
       +
       		}

     

       851
       851
       +
       

     

       852
       852
       +
       	} else {

     

       853
       853
       +
       		openInt := 0

     

       854
       854
       +
       		if isOpen {

     

       855
       855
       +
       			openInt = 1

     

       856
       856
       +
       		}

     

       857
       857
       +
       		issues, err = db.GetIssuesPaginated(

     

       858
       858
       +
       			rp.db,

     

       859
       859
       +
       			page,

     

       860
       860
       +
       			orm.FilterEq("repo_at", f.RepoAt()),

     

       861
       861
       +
       			orm.FilterEq("open", openInt),

     

       862
       862
       +
       		)

     

       863
       863
       +
       		if err != nil {

     

       864
       864
       +
       			l.Error("failed to get issues", "err", err)

     

       865
       865
       +
       			rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       866
       866
       +
       			return

     

       867
       867
       +
       		}

     

       800
       868
        
       	}

     

       801
       869
        
       

     

       802
       870
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       803
       871
        
       		rp.db,

     

       804
       804
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       805
       805
       -
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       872
       872
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       873
       873
       +
       		orm.FilterContains("scope", tangled.RepoIssueNSID),

     

       806
       874
        
       	)

     

       807
       875
        
       	if err != nil {

     

       808
       876
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       817
       885
        
       

     

       818
       886
        
       	rp.pages.RepoIssues(w, pages.RepoIssuesParams{

     

       819
       887
        
       		LoggedInUser:    rp.oauth.GetUser(r),

     

       820
       820
       -
       		RepoInfo:        f.RepoInfo(user),

     

       888
       888
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       821
       889
        
       		Issues:          issues,

     

       890
       890
       +
       		IssueCount:      totalIssues,

     

       822
       891
        
       		LabelDefs:       defs,

     

       823
       892
        
       		FilteringByOpen: isOpen,

     

       893
       893
       +
       		FilterQuery:     keyword,

     

       824
       894
        
       		Page:            page,

     

       825
       895
        
       	})

     

       826
       896
        
       }

     
···

       839
       909
        
       	case http.MethodGet:

     

       840
       910
        
       		rp.pages.RepoNewIssue(w, pages.RepoNewIssueParams{

     

       841
       911
        
       			LoggedInUser: user,

     

       842
       842
       -
       			RepoInfo:     f.RepoInfo(user),

     

       912
       912
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       843
       913
        
       		})

     

       844
       914
        
       	case http.MethodPost:

     

       915
       915
       +
       		body := r.FormValue("body")

     

       916
       916
       +
       		mentions, references := rp.mentionsResolver.Resolve(r.Context(), body)

     

       917
       917
       +
       

     

       845
       918
        
       		issue := &models.Issue{

     

       846
       846
       -
       			RepoAt:  f.RepoAt(),

     

       847
       847
       -
       			Rkey:    tid.TID(),

     

       848
       848
       -
       			Title:   r.FormValue("title"),

     

       849
       849
       -
       			Body:    r.FormValue("body"),

     

       850
       850
       -
       			Did:     user.Did,

     

       851
       851
       -
       			Created: time.Now(),

     

       852
       852
       -
       			Repo:    &f.Repo,

     

       919
       919
       +
       			RepoAt:     f.RepoAt(),

     

       920
       920
       +
       			Rkey:       tid.TID(),

     

       921
       921
       +
       			Title:      r.FormValue("title"),

     

       922
       922
       +
       			Body:       body,

     

       923
       923
       +
       			Open:       true,

     

       924
       924
       +
       			Did:        user.Did,

     

       925
       925
       +
       			Created:    time.Now(),

     

       926
       926
       +
       			Mentions:   mentions,

     

       927
       927
       +
       			References: references,

     

       928
       928
       +
       			Repo:       f,

     

       853
       929
        
       		}

     

       854
       930
        
       

     

       855
       931
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

     
···

       916
       992
        
       

     

       917
       993
        
       		// everything is successful, do not rollback the atproto record

     

       918
       994
        
       		atUri = ""

     

       919
       919
       -
       		rp.notifier.NewIssue(r.Context(), issue)

     

       920
       920
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       995
       995
       +
       

     

       996
       996
       +
       		rp.notifier.NewIssue(r.Context(), issue, mentions)

     

       997
       997
       +
       

     

       998
       998
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       999
       999
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))

     

       921
       1000
        
       		return

     

       922
       1001
        
       	}

     

       923
       1002
        
       }

+8 -8

appview/issues/opengraph.go

···

       143
       143
        
       	var statusBgColor color.RGBA

     

       144
       144
        
       

     

       145
       145
        
       	if issue.Open {

     

       146
       146
       -
       		statusIcon = "static/icons/circle-dot.svg"

     

       146
       146
       +
       		statusIcon = "circle-dot"

     

       147
       147
        
       		statusText = "open"

     

       148
       148
        
       		statusBgColor = color.RGBA{34, 139, 34, 255} // green

     

       149
       149
        
       	} else {

     

       150
       150
       -
       		statusIcon = "static/icons/circle-dot.svg"

     

       150
       150
       +
       		statusIcon = "ban"

     

       151
       151
        
       		statusText = "closed"

     

       152
       152
        
       		statusBgColor = color.RGBA{52, 58, 64, 255} // dark gray

     

       153
       153
        
       	}

     
···

       155
       155
        
       	badgeIconSize := 36

     

       156
       156
        
       

     

       157
       157
        
       	// Draw icon with status color (no background)

     

       158
       158
       -
       	err = statusCommentsArea.DrawSVGIcon(statusIcon, statsX, statsY+iconBaselineOffset-badgeIconSize/2+5, badgeIconSize, statusBgColor)

     

       158
       158
       +
       	err = statusCommentsArea.DrawLucideIcon(statusIcon, statsX, statsY+iconBaselineOffset-badgeIconSize/2+5, badgeIconSize, statusBgColor)

     

       159
       159
        
       	if err != nil {

     

       160
       160
        
       		log.Printf("failed to draw status icon: %v", err)

     

       161
       161
        
       	}

     
···

       172
       172
        
       	currentX := statsX + badgeIconSize + 12 + statusTextWidth + 50

     

       173
       173
        
       

     

       174
       174
        
       	// Draw comment count

     

       175
       175
       -
       	err = statusCommentsArea.DrawSVGIcon("static/icons/message-square.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       175
       175
       +
       	err = statusCommentsArea.DrawLucideIcon("message-square", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       176
       176
        
       	if err != nil {

     

       177
       177
        
       		log.Printf("failed to draw comment icon: %v", err)

     

       178
       178
        
       	}

     
···

       193
       193
        
       	dollyX := dollyBounds.Min.X + (dollyBounds.Dx() / 2) - (dollySize / 2)

     

       194
       194
        
       	dollyY := statsY + iconBaselineOffset - dollySize/2 + 25

     

       195
       195
        
       	dollyColor := color.RGBA{180, 180, 180, 255} // light gray

     

       196
       196
       -
       	err = dollyArea.DrawSVGIcon("templates/fragments/dolly/silhouette.svg", dollyX, dollyY, dollySize, dollyColor)

     

       196
       196
       +
       	err = dollyArea.DrawDollySilhouette(dollyX, dollyY, dollySize, dollyColor)

     

       197
       197
        
       	if err != nil {

     

       198
       198
        
       		log.Printf("dolly silhouette not available (this is ok): %v", err)

     

       199
       199
        
       	}

     
···

       232
       232
        
       

     

       233
       233
        
       	// Get owner handle for avatar

     

       234
       234
        
       	var ownerHandle string

     

       235
       235
       -
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)

     

       235
       235
       +
       	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       236
       236
        
       	if err != nil {

     

       237
       237
       -
       		ownerHandle = f.Repo.Did

     

       237
       237
       +
       		ownerHandle = f.Did

     

       238
       238
        
       	} else {

     

       239
       239
        
       		ownerHandle = "@" + owner.Handle.String()

     

       240
       240
        
       	}

     

       241
       241
        
       

     

       242
       242
       -
       	card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)

     

       242
       242
       +
       	card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)

     

       243
       243
        
       	if err != nil {

     

       244
       244
        
       		log.Println("failed to draw issue summary card", err)

     

       245
       245
        
       		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

+46 -19

appview/knots/knots.go

···

       6
       6
        
       	"log/slog"

     

       7
       7
        
       	"net/http"

     

       8
       8
        
       	"slices"

     

       9
       9
       +
       	"strings"

     

       9
       10
        
       	"time"

     

       10
       11
        
       

     

       11
       12
        
       	"github.com/go-chi/chi/v5"

     
···

       20
       21
        
       	"tangled.org/core/appview/xrpcclient"

     

       21
       22
        
       	"tangled.org/core/eventconsumer"

     

       22
       23
        
       	"tangled.org/core/idresolver"

     

       24
       24
       +
       	"tangled.org/core/orm"

     

       23
       25
        
       	"tangled.org/core/rbac"

     

       24
       26
        
       	"tangled.org/core/tid"

     

       25
       27
        
       

     
···

       38
       40
        
       	Knotstream *eventconsumer.Consumer

     

       39
       41
        
       }

     

       40
       42
        
       

     

       43
       43
       +
       type tab = map[string]any

     

       44
       44
       +
       

     

       45
       45
       +
       var (

     

       46
       46
       +
       	knotsTabs []tab = []tab{

     

       47
       47
       +
       		{"Name": "profile", "Icon": "user"},

     

       48
       48
       +
       		{"Name": "keys", "Icon": "key"},

     

       49
       49
       +
       		{"Name": "emails", "Icon": "mail"},

     

       50
       50
       +
       		{"Name": "notifications", "Icon": "bell"},

     

       51
       51
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       52
       52
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       53
       53
       +
       	}

     

       54
       54
       +
       )

     

       55
       55
       +
       

     

       41
       56
        
       func (k *Knots) Router() http.Handler {

     

       42
       57
        
       	r := chi.NewRouter()

     

       43
       58
        
       

     
···

       58
       73
        
       	user := k.OAuth.GetUser(r)

     

       59
       74
        
       	registrations, err := db.GetRegistrations(

     

       60
       75
        
       		k.Db,

     

       61
       61
       -
       		db.FilterEq("did", user.Did),

     

       76
       76
       +
       		orm.FilterEq("did", user.Did),

     

       62
       77
        
       	)

     

       63
       78
        
       	if err != nil {

     

       64
       79
        
       		k.Logger.Error("failed to fetch knot registrations", "err", err)

     
···

       69
       84
        
       	k.Pages.Knots(w, pages.KnotsParams{

     

       70
       85
        
       		LoggedInUser:  user,

     

       71
       86
        
       		Registrations: registrations,

     

       87
       87
       +
       		Tabs:          knotsTabs,

     

       88
       88
       +
       		Tab:           "knots",

     

       72
       89
        
       	})

     

       73
       90
        
       }

     

       74
       91
        
       

     
···

       86
       103
        
       

     

       87
       104
        
       	registrations, err := db.GetRegistrations(

     

       88
       105
        
       		k.Db,

     

       89
       89
       -
       		db.FilterEq("did", user.Did),

     

       90
       90
       -
       		db.FilterEq("domain", domain),

     

       106
       106
       +
       		orm.FilterEq("did", user.Did),

     

       107
       107
       +
       		orm.FilterEq("domain", domain),

     

       91
       108
        
       	)

     

       92
       109
        
       	if err != nil {

     

       93
       110
        
       		l.Error("failed to get registrations", "err", err)

     
···

       111
       128
        
       	repos, err := db.GetRepos(

     

       112
       129
        
       		k.Db,

     

       113
       130
        
       		0,

     

       114
       114
       -
       		db.FilterEq("knot", domain),

     

       131
       131
       +
       		orm.FilterEq("knot", domain),

     

       115
       132
        
       	)

     

       116
       133
        
       	if err != nil {

     

       117
       134
        
       		l.Error("failed to get knot repos", "err", err)

     
···

       131
       148
        
       		Members:      members,

     

       132
       149
        
       		Repos:        repoMap,

     

       133
       150
        
       		IsOwner:      true,

     

       151
       151
       +
       		Tabs:         knotsTabs,

     

       152
       152
       +
       		Tab:          "knots",

     

       134
       153
        
       	})

     

       135
       154
        
       }

     

       136
       155
        
       

     
···

       145
       164
        
       	}

     

       146
       165
        
       

     

       147
       166
        
       	domain := r.FormValue("domain")

     

       167
       167
       +
       	// Strip protocol, trailing slashes, and whitespace

     

       168
       168
       +
       	// Rkey cannot contain slashes

     

       169
       169
       +
       	domain = strings.TrimSpace(domain)

     

       170
       170
       +
       	domain = strings.TrimPrefix(domain, "https://")

     

       171
       171
       +
       	domain = strings.TrimPrefix(domain, "http://")

     

       172
       172
       +
       	domain = strings.TrimSuffix(domain, "/")

     

       148
       173
        
       	if domain == "" {

     

       149
       174
        
       		k.Pages.Notice(w, noticeId, "Incomplete form.")

     

       150
       175
        
       		return

     
···

       269
       294
        
       	// get record from db first

     

       270
       295
        
       	registrations, err := db.GetRegistrations(

     

       271
       296
        
       		k.Db,

     

       272
       272
       -
       		db.FilterEq("did", user.Did),

     

       273
       273
       -
       		db.FilterEq("domain", domain),

     

       297
       297
       +
       		orm.FilterEq("did", user.Did),

     

       298
       298
       +
       		orm.FilterEq("domain", domain),

     

       274
       299
        
       	)

     

       275
       300
        
       	if err != nil {

     

       276
       301
        
       		l.Error("failed to get registration", "err", err)

     
···

       297
       322
        
       

     

       298
       323
        
       	err = db.DeleteKnot(

     

       299
       324
        
       		tx,

     

       300
       300
       -
       		db.FilterEq("did", user.Did),

     

       301
       301
       -
       		db.FilterEq("domain", domain),

     

       325
       325
       +
       		orm.FilterEq("did", user.Did),

     

       326
       326
       +
       		orm.FilterEq("domain", domain),

     

       302
       327
        
       	)

     

       303
       328
        
       	if err != nil {

     

       304
       329
        
       		l.Error("failed to delete registration", "err", err)

     
···

       378
       403
        
       	// get record from db first

     

       379
       404
        
       	registrations, err := db.GetRegistrations(

     

       380
       405
        
       		k.Db,

     

       381
       381
       -
       		db.FilterEq("did", user.Did),

     

       382
       382
       -
       		db.FilterEq("domain", domain),

     

       406
       406
       +
       		orm.FilterEq("did", user.Did),

     

       407
       407
       +
       		orm.FilterEq("domain", domain),

     

       383
       408
        
       	)

     

       384
       409
        
       	if err != nil {

     

       385
       410
        
       		l.Error("failed to get registration", "err", err)

     
···

       469
       494
        
       	// Get updated registration to show

     

       470
       495
        
       	registrations, err = db.GetRegistrations(

     

       471
       496
        
       		k.Db,

     

       472
       472
       -
       		db.FilterEq("did", user.Did),

     

       473
       473
       -
       		db.FilterEq("domain", domain),

     

       497
       497
       +
       		orm.FilterEq("did", user.Did),

     

       498
       498
       +
       		orm.FilterEq("domain", domain),

     

       474
       499
        
       	)

     

       475
       500
        
       	if err != nil {

     

       476
       501
        
       		l.Error("failed to get registration", "err", err)

     
···

       505
       530
        
       

     

       506
       531
        
       	registrations, err := db.GetRegistrations(

     

       507
       532
        
       		k.Db,

     

       508
       508
       -
       		db.FilterEq("did", user.Did),

     

       509
       509
       -
       		db.FilterEq("domain", domain),

     

       510
       510
       -
       		db.FilterIsNot("registered", "null"),

     

       533
       533
       +
       		orm.FilterEq("did", user.Did),

     

       534
       534
       +
       		orm.FilterEq("domain", domain),

     

       535
       535
       +
       		orm.FilterIsNot("registered", "null"),

     

       511
       536
        
       	)

     

       512
       537
        
       	if err != nil {

     

       513
       538
        
       		l.Error("failed to get registration", "err", err)

     
···

       526
       551
        
       	}

     

       527
       552
        
       

     

       528
       553
        
       	member := r.FormValue("member")

     

       554
       554
       +
       	member = strings.TrimPrefix(member, "@")

     

       529
       555
        
       	if member == "" {

     

       530
       556
        
       		l.Error("empty member")

     

       531
       557
        
       		k.Pages.Notice(w, noticeId, "Failed to add member, empty form.")

     
···

       588
       614
        
       	}

     

       589
       615
        
       

     

       590
       616
        
       	// success

     

       591
       591
       -
       	k.Pages.HxRedirect(w, fmt.Sprintf("/knots/%s", domain))

     

       617
       617
       +
       	k.Pages.HxRedirect(w, fmt.Sprintf("/settings/knots/%s", domain))

     

       592
       618
        
       }

     

       593
       619
        
       

     

       594
       620
        
       func (k *Knots) removeMember(w http.ResponseWriter, r *http.Request) {

     
···

       612
       638
        
       

     

       613
       639
        
       	registrations, err := db.GetRegistrations(

     

       614
       640
        
       		k.Db,

     

       615
       615
       -
       		db.FilterEq("did", user.Did),

     

       616
       616
       -
       		db.FilterEq("domain", domain),

     

       617
       617
       -
       		db.FilterIsNot("registered", "null"),

     

       641
       641
       +
       		orm.FilterEq("did", user.Did),

     

       642
       642
       +
       		orm.FilterEq("domain", domain),

     

       643
       643
       +
       		orm.FilterIsNot("registered", "null"),

     

       618
       644
        
       	)

     

       619
       645
        
       	if err != nil {

     

       620
       646
        
       		l.Error("failed to get registration", "err", err)

     
···

       626
       652
        
       	}

     

       627
       653
        
       

     

       628
       654
        
       	member := r.FormValue("member")

     

       655
       655
       +
       	member = strings.TrimPrefix(member, "@")

     

       629
       656
        
       	if member == "" {

     

       630
       657
        
       		l.Error("empty member")

     

       631
       658
        
       		k.Pages.Notice(w, noticeId, "Failed to remove member, empty form.")

+6 -5

appview/labels/labels.go

···

       16
       16
        
       	"tangled.org/core/appview/oauth"

     

       17
       17
        
       	"tangled.org/core/appview/pages"

     

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

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	"tangled.org/core/tid"

     

       21
       22
        
       

     
···

       53
       54
        
       	}

     

       54
       55
        
       }

     

       55
       56
        
       

     

       56
       56
       -
       func (l *Labels) Router(mw *middleware.Middleware) http.Handler {

     

       57
       57
       +
       func (l *Labels) Router() http.Handler {

     

       57
       58
        
       	r := chi.NewRouter()

     

       58
       59
        
       

     

       59
       60
        
       	r.Use(middleware.AuthMiddleware(l.oauth))

     
···

       88
       89
        
       	repoAt := r.Form.Get("repo")

     

       89
       90
        
       	subjectUri := r.Form.Get("subject")

     

       90
       91
        
       

     

       91
       91
       -
       	repo, err := db.GetRepo(l.db, db.FilterEq("at_uri", repoAt))

     

       92
       92
       +
       	repo, err := db.GetRepo(l.db, orm.FilterEq("at_uri", repoAt))

     

       92
       93
        
       	if err != nil {

     

       93
       94
        
       		fail("Failed to get repository.", err)

     

       94
       95
        
       		return

     

       95
       96
        
       	}

     

       96
       97
        
       

     

       97
       98
        
       	// find all the labels that this repo subscribes to

     

       98
       98
       -
       	repoLabels, err := db.GetRepoLabels(l.db, db.FilterEq("repo_at", repoAt))

     

       99
       99
       +
       	repoLabels, err := db.GetRepoLabels(l.db, orm.FilterEq("repo_at", repoAt))

     

       99
       100
        
       	if err != nil {

     

       100
       101
        
       		fail("Failed to get labels for this repository.", err)

     

       101
       102
        
       		return

     
···

       106
       107
        
       		labelAts = append(labelAts, rl.LabelAt.String())

     

       107
       108
        
       	}

     

       108
       109
        
       

     

       109
       109
       -
       	actx, err := db.NewLabelApplicationCtx(l.db, db.FilterIn("at_uri", labelAts))

     

       110
       110
       +
       	actx, err := db.NewLabelApplicationCtx(l.db, orm.FilterIn("at_uri", labelAts))

     

       110
       111
        
       	if err != nil {

     

       111
       112
        
       		fail("Invalid form data.", err)

     

       112
       113
        
       		return

     

       113
       114
        
       	}

     

       114
       115
        
       

     

       115
       116
        
       	// calculate the start state by applying already known labels

     

       116
       116
       -
       	existingOps, err := db.GetLabelOps(l.db, db.FilterEq("subject", subjectUri))

     

       117
       117
       +
       	existingOps, err := db.GetLabelOps(l.db, orm.FilterEq("subject", subjectUri))

     

       117
       118
        
       	if err != nil {

     

       118
       119
        
       		fail("Invalid form data.", err)

     

       119
       120
        
       		return

+67

appview/mentions/resolver.go

···

       1
       1
       +
       package mentions

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type Resolver struct {

     

       16
       16
       +
       	config     *config.Config

     

       17
       17
       +
       	idResolver *idresolver.Resolver

     

       18
       18
       +
       	execer     db.Execer

     

       19
       19
       +
       	logger     *slog.Logger

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func New(

     

       23
       23
       +
       	config *config.Config,

     

       24
       24
       +
       	idResolver *idresolver.Resolver,

     

       25
       25
       +
       	execer db.Execer,

     

       26
       26
       +
       	logger *slog.Logger,

     

       27
       27
       +
       ) *Resolver {

     

       28
       28
       +
       	return &Resolver{

     

       29
       29
       +
       		config,

     

       30
       30
       +
       		idResolver,

     

       31
       31
       +
       		execer,

     

       32
       32
       +
       		logger,

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) {

     

       37
       37
       +
       	l := r.logger.With("method", "Resolve")

     

       38
       38
       +
       

     

       39
       39
       +
       	rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source)

     

       40
       40
       +
       	l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs)

     

       41
       41
       +
       

     

       42
       42
       +
       	idents := r.idResolver.ResolveIdents(ctx, rawMentions)

     

       43
       43
       +
       	var mentions []syntax.DID

     

       44
       44
       +
       	for _, ident := range idents {

     

       45
       45
       +
       		if ident != nil && !ident.Handle.IsInvalidHandle() {

     

       46
       46
       +
       			mentions = append(mentions, ident.DID)

     

       47
       47
       +
       		}

     

       48
       48
       +
       	}

     

       49
       49
       +
       	l.Debug("found mentions", "mentions", mentions)

     

       50
       50
       +
       

     

       51
       51
       +
       	var resolvedRefs []models.ReferenceLink

     

       52
       52
       +
       	for _, rawRef := range rawRefs {

     

       53
       53
       +
       		ident, err := r.idResolver.ResolveIdent(ctx, rawRef.Handle)

     

       54
       54
       +
       		if err != nil || ident == nil || ident.Handle.IsInvalidHandle() {

     

       55
       55
       +
       			continue

     

       56
       56
       +
       		}

     

       57
       57
       +
       		rawRef.Handle = string(ident.DID)

     

       58
       58
       +
       		resolvedRefs = append(resolvedRefs, rawRef)

     

       59
       59
       +
       	}

     

       60
       60
       +
       	aturiRefs, err := db.ValidateReferenceLinks(r.execer, resolvedRefs)

     

       61
       61
       +
       	if err != nil {

     

       62
       62
       +
       		l.Error("failed running query", "err", err)

     

       63
       63
       +
       	}

     

       64
       64
       +
       	l.Debug("found references", "refs", aturiRefs)

     

       65
       65
       +
       

     

       66
       66
       +
       	return mentions, aturiRefs

     

       67
       67
       +
       }

+16 -20

appview/middleware/middleware.go

···

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

     

       19
       19
        
       	"tangled.org/core/appview/reporesolver"

     

       20
       20
        
       	"tangled.org/core/idresolver"

     

       21
       21
       +
       	"tangled.org/core/orm"

     

       21
       22
        
       	"tangled.org/core/rbac"

     

       22
       23
        
       )

     

       23
       24
        
       

     
···

       105
       106
        
       			}

     

       106
       107
        
       		}

     

       107
       108
        
       

     

       108
       108
       -
       		ctx := context.WithValue(r.Context(), "page", page)

     

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

     

       109
       110
        
       		next.ServeHTTP(w, r.WithContext(ctx))

     

       110
       111
        
       	})

     

       111
       112
        
       }

     
···

       164
       165
        
       			ok, err := mw.enforcer.E.Enforce(actor.Did, f.Knot, f.DidSlashRepo(), requiredPerm)

     

       165
       166
        
       			if err != nil || !ok {

     

       166
       167
        
       				// we need a logged in user

     

       167
       167
       -
       				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.OwnerSlashRepo())

     

       168
       168
       +
       				log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.DidSlashRepo())

     

       168
       169
        
       				http.Error(w, "Forbiden", http.StatusUnauthorized)

     

       169
       170
        
       				return

     

       170
       171
        
       			}

     
···

       180
       181
        
       	return func(next http.Handler) http.Handler {

     

       181
       182
        
       		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       182
       183
        
       			didOrHandle := chi.URLParam(req, "user")

     

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

     

       185
       185
       +
       

     

       183
       186
        
       			if slices.Contains(excluded, didOrHandle) {

     

       184
       187
        
       				next.ServeHTTP(w, req)

     

       185
       188
        
       				return

     

       186
       189
        
       			}

     

       187
       187
       -
       

     

       188
       188
       -
       			didOrHandle = strings.TrimPrefix(didOrHandle, "@")

     

       189
       190
        
       

     

       190
       191
        
       			id, err := mw.idResolver.ResolveIdent(req.Context(), didOrHandle)

     

       191
       192
        
       			if err != nil {

     
···

       206
       207
        
       	return func(next http.Handler) http.Handler {

     

       207
       208
        
       		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {

     

       208
       209
        
       			repoName := chi.URLParam(req, "repo")

     

       210
       210
       +
       			repoName = strings.TrimSuffix(repoName, ".git")

     

       211
       211
       +
       

     

       209
       212
        
       			id, ok := req.Context().Value("resolvedId").(identity.Identity)

     

       210
       213
        
       			if !ok {

     

       211
       214
        
       				log.Println("malformed middleware")

     
···

       215
       218
        
       

     

       216
       219
        
       			repo, err := db.GetRepo(

     

       217
       220
        
       				mw.db,

     

       218
       218
       -
       				db.FilterEq("did", id.DID.String()),

     

       219
       219
       -
       				db.FilterEq("name", repoName),

     

       221
       221
       +
       				orm.FilterEq("did", id.DID.String()),

     

       222
       222
       +
       				orm.FilterEq("name", repoName),

     

       220
       223
        
       			)

     

       221
       224
        
       			if err != nil {

     

       222
       225
        
       				log.Println("failed to resolve repo", "err", err)

     
···

       244
       247
        
       			prId := chi.URLParam(r, "pull")

     

       245
       248
        
       			prIdInt, err := strconv.Atoi(prId)

     

       246
       249
        
       			if err != nil {

     

       247
       247
       -
       				http.Error(w, "bad pr id", http.StatusBadRequest)

     

       248
       250
        
       				log.Println("failed to parse pr id", err)

     

       251
       251
       +
       				mw.pages.Error404(w)

     

       249
       252
        
       				return

     

       250
       253
        
       			}

     

       251
       254
        
       

     

       252
       255
        
       			pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)

     

       253
       256
        
       			if err != nil {

     

       254
       257
        
       				log.Println("failed to get pull and comments", err)

     

       258
       258
       +
       				mw.pages.Error404(w)

     

       255
       259
        
       				return

     

       256
       260
        
       			}

     

       257
       261
        
       

     
···

       292
       296
        
       		issueId, err := strconv.Atoi(issueIdStr)

     

       293
       297
        
       		if err != nil {

     

       294
       298
        
       			log.Println("failed to fully resolve issue ID", err)

     

       295
       295
       -
       			mw.pages.ErrorKnot404(w)

     

       299
       299
       +
       			mw.pages.Error404(w)

     

       296
       300
        
       			return

     

       297
       301
        
       		}

     

       298
       302
        
       

     

       299
       299
       -
       		issues, err := db.GetIssues(

     

       300
       300
       -
       			mw.db,

     

       301
       301
       -
       			db.FilterEq("repo_at", f.RepoAt()),

     

       302
       302
       -
       			db.FilterEq("issue_id", issueId),

     

       303
       303
       -
       		)

     

       303
       303
       +
       		issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId)

     

       304
       304
        
       		if err != nil {

     

       305
       305
        
       			log.Println("failed to get issues", "err", err)

     

       306
       306
       -
       			return

     

       307
       307
       -
       		}

     

       308
       308
       -
       		if len(issues) != 1 {

     

       309
       309
       -
       			log.Println("got incorrect number of issues", "len(issuse)", len(issues))

     

       306
       306
       +
       			mw.pages.Error404(w)

     

       310
       307
        
       			return

     

       311
       308
        
       		}

     

       312
       312
       -
       		issue := issues[0]

     

       313
       309
        
       

     

       314
       314
       -
       		ctx := context.WithValue(r.Context(), "issue", &issue)

     

       310
       310
       +
       		ctx := context.WithValue(r.Context(), "issue", issue)

     

       315
       311
        
       		next.ServeHTTP(w, r.WithContext(ctx))

     

       316
       312
        
       	})

     

       317
       313
        
       }

     
···

       332
       328
        
       				return

     

       333
       329
        
       			}

     

       334
       330
        
       

     

       335
       335
       -
       			fullName := f.OwnerHandle() + "/" + f.Name

     

       331
       331
       +
       			fullName := reporesolver.GetBaseRepoPath(r, f)

     

       336
       332
        
       

     

       337
       333
        
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       338
       334
        
       				if r.URL.Query().Get("go-get") == "1" {

+70 -34

appview/models/issue.go

···

       10
       10
        
       )

     

       11
       11
        
       

     

       12
       12
        
       type Issue struct {

     

       13
       13
       -
       	Id      int64

     

       14
       14
       -
       	Did     string

     

       15
       15
       -
       	Rkey    string

     

       16
       16
       -
       	RepoAt  syntax.ATURI

     

       17
       17
       -
       	IssueId int

     

       18
       18
       -
       	Created time.Time

     

       19
       19
       -
       	Edited  *time.Time

     

       20
       20
       -
       	Deleted *time.Time

     

       21
       21
       -
       	Title   string

     

       22
       22
       -
       	Body    string

     

       23
       23
       -
       	Open    bool

     

       13
       13
       +
       	Id         int64

     

       14
       14
       +
       	Did        string

     

       15
       15
       +
       	Rkey       string

     

       16
       16
       +
       	RepoAt     syntax.ATURI

     

       17
       17
       +
       	IssueId    int

     

       18
       18
       +
       	Created    time.Time

     

       19
       19
       +
       	Edited     *time.Time

     

       20
       20
       +
       	Deleted    *time.Time

     

       21
       21
       +
       	Title      string

     

       22
       22
       +
       	Body       string

     

       23
       23
       +
       	Open       bool

     

       24
       24
       +
       	Mentions   []syntax.DID

     

       25
       25
       +
       	References []syntax.ATURI

     

       24
       26
        
       

     

       25
       27
        
       	// optionally, populate this when querying for reverse mappings

     

       26
       28
        
       	// like comment counts, parent repo etc.

     
···

       34
       36
        
       }

     

       35
       37
        
       

     

       36
       38
        
       func (i *Issue) AsRecord() tangled.RepoIssue {

     

       39
       39
       +
       	mentions := make([]string, len(i.Mentions))

     

       40
       40
       +
       	for i, did := range i.Mentions {

     

       41
       41
       +
       		mentions[i] = string(did)

     

       42
       42
       +
       	}

     

       43
       43
       +
       	references := make([]string, len(i.References))

     

       44
       44
       +
       	for i, uri := range i.References {

     

       45
       45
       +
       		references[i] = string(uri)

     

       46
       46
       +
       	}

     

       37
       47
        
       	return tangled.RepoIssue{

     

       38
       38
       -
       		Repo:      i.RepoAt.String(),

     

       39
       39
       -
       		Title:     i.Title,

     

       40
       40
       -
       		Body:      &i.Body,

     

       41
       41
       -
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       48
       48
       +
       		Repo:       i.RepoAt.String(),

     

       49
       49
       +
       		Title:      i.Title,

     

       50
       50
       +
       		Body:       &i.Body,

     

       51
       51
       +
       		Mentions:   mentions,

     

       52
       52
       +
       		References: references,

     

       53
       53
       +
       		CreatedAt:  i.Created.Format(time.RFC3339),

     

       42
       54
        
       	}

     

       43
       55
        
       }

     

       44
       56
        
       

     
···

       161
       173
        
       }

     

       162
       174
        
       

     

       163
       175
        
       type IssueComment struct {

     

       164
       164
       -
       	Id      int64

     

       165
       165
       -
       	Did     string

     

       166
       166
       -
       	Rkey    string

     

       167
       167
       -
       	IssueAt string

     

       168
       168
       -
       	ReplyTo *string

     

       169
       169
       -
       	Body    string

     

       170
       170
       -
       	Created time.Time

     

       171
       171
       -
       	Edited  *time.Time

     

       172
       172
       -
       	Deleted *time.Time

     

       176
       176
       +
       	Id         int64

     

       177
       177
       +
       	Did        string

     

       178
       178
       +
       	Rkey       string

     

       179
       179
       +
       	IssueAt    string

     

       180
       180
       +
       	ReplyTo    *string

     

       181
       181
       +
       	Body       string

     

       182
       182
       +
       	Created    time.Time

     

       183
       183
       +
       	Edited     *time.Time

     

       184
       184
       +
       	Deleted    *time.Time

     

       185
       185
       +
       	Mentions   []syntax.DID

     

       186
       186
       +
       	References []syntax.ATURI

     

       173
       187
        
       }

     

       174
       188
        
       

     

       175
       189
        
       func (i *IssueComment) AtUri() syntax.ATURI {

     
···

       177
       191
        
       }

     

       178
       192
        
       

     

       179
       193
        
       func (i *IssueComment) AsRecord() tangled.RepoIssueComment {

     

       194
       194
       +
       	mentions := make([]string, len(i.Mentions))

     

       195
       195
       +
       	for i, did := range i.Mentions {

     

       196
       196
       +
       		mentions[i] = string(did)

     

       197
       197
       +
       	}

     

       198
       198
       +
       	references := make([]string, len(i.References))

     

       199
       199
       +
       	for i, uri := range i.References {

     

       200
       200
       +
       		references[i] = string(uri)

     

       201
       201
       +
       	}

     

       180
       202
        
       	return tangled.RepoIssueComment{

     

       181
       181
       -
       		Body:      i.Body,

     

       182
       182
       -
       		Issue:     i.IssueAt,

     

       183
       183
       -
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       184
       184
       -
       		ReplyTo:   i.ReplyTo,

     

       203
       203
       +
       		Body:       i.Body,

     

       204
       204
       +
       		Issue:      i.IssueAt,

     

       205
       205
       +
       		CreatedAt:  i.Created.Format(time.RFC3339),

     

       206
       206
       +
       		ReplyTo:    i.ReplyTo,

     

       207
       207
       +
       		Mentions:   mentions,

     

       208
       208
       +
       		References: references,

     

       185
       209
        
       	}

     

       186
       210
        
       }

     

       187
       211
        
       

     
···

       205
       229
        
       		return nil, err

     

       206
       230
        
       	}

     

       207
       231
        
       

     

       232
       232
       +
       	i := record

     

       233
       233
       +
       	mentions := make([]syntax.DID, len(record.Mentions))

     

       234
       234
       +
       	for i, did := range record.Mentions {

     

       235
       235
       +
       		mentions[i] = syntax.DID(did)

     

       236
       236
       +
       	}

     

       237
       237
       +
       	references := make([]syntax.ATURI, len(record.References))

     

       238
       238
       +
       	for i, uri := range i.References {

     

       239
       239
       +
       		references[i] = syntax.ATURI(uri)

     

       240
       240
       +
       	}

     

       241
       241
       +
       

     

       208
       242
        
       	comment := IssueComment{

     

       209
       209
       -
       		Did:     ownerDid,

     

       210
       210
       -
       		Rkey:    rkey,

     

       211
       211
       -
       		Body:    record.Body,

     

       212
       212
       -
       		IssueAt: record.Issue,

     

       213
       213
       -
       		ReplyTo: record.ReplyTo,

     

       214
       214
       -
       		Created: created,

     

       243
       243
       +
       		Did:        ownerDid,

     

       244
       244
       +
       		Rkey:       rkey,

     

       245
       245
       +
       		Body:       record.Body,

     

       246
       246
       +
       		IssueAt:    record.Issue,

     

       247
       247
       +
       		ReplyTo:    record.ReplyTo,

     

       248
       248
       +
       		Created:    created,

     

       249
       249
       +
       		Mentions:   mentions,

     

       250
       250
       +
       		References: references,

     

       215
       251
        
       	}

     

       216
       252
        
       

     

       217
       253
        
       	return &comment, nil

+25 -43

appview/models/label.go

···

       14
       14
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       15
       15
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       16
       16
        
       	"tangled.org/core/api/tangled"

     

       17
       17
       -
       	"tangled.org/core/consts"

     

       18
       17
        
       	"tangled.org/core/idresolver"

     

       19
       18
        
       )

     

       20
       19
        
       

     
···

       461
       460
        
       	return result

     

       462
       461
        
       }

     

       463
       462
        
       

     

       464
       464
       -
       var (

     

       465
       465
       -
       	LabelWontfix        = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "wontfix")

     

       466
       466
       -
       	LabelDuplicate      = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "duplicate")

     

       467
       467
       -
       	LabelAssignee       = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "assignee")

     

       468
       468
       -
       	LabelGoodFirstIssue = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "good-first-issue")

     

       469
       469
       -
       	LabelDocumentation  = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "documentation")

     

       470
       470
       -
       )

     

       463
       463
       +
       func FetchLabelDefs(r *idresolver.Resolver, aturis []string) ([]LabelDefinition, error) {

     

       464
       464
       +
       	var labelDefs []LabelDefinition

     

       465
       465
       +
       	ctx := context.Background()

     

       471
       466
        
       

     

       472
       472
       -
       func DefaultLabelDefs() []string {

     

       473
       473
       -
       	return []string{

     

       474
       474
       -
       		LabelWontfix,

     

       475
       475
       -
       		LabelDuplicate,

     

       476
       476
       -
       		LabelAssignee,

     

       477
       477
       -
       		LabelGoodFirstIssue,

     

       478
       478
       -
       		LabelDocumentation,

     

       479
       479
       -
       	}

     

       480
       480
       -
       }

     

       467
       467
       +
       	for _, dl := range aturis {

     

       468
       468
       +
       		atUri, err := syntax.ParseATURI(dl)

     

       469
       469
       +
       		if err != nil {

     

       470
       470
       +
       			return nil, fmt.Errorf("failed to parse AT-URI %s: %v", dl, err)

     

       471
       471
       +
       		}

     

       472
       472
       +
       		if atUri.Collection() != tangled.LabelDefinitionNSID {

     

       473
       473
       +
       			return nil, fmt.Errorf("expected AT-URI pointing %s collection: %s", tangled.LabelDefinitionNSID, atUri)

     

       474
       474
       +
       		}

     

       481
       475
        
       

     

       482
       482
       -
       func FetchDefaultDefs(r *idresolver.Resolver) ([]LabelDefinition, error) {

     

       483
       483
       -
       	resolved, err := r.ResolveIdent(context.Background(), consts.TangledDid)

     

       484
       484
       -
       	if err != nil {

     

       485
       485
       -
       		return nil, fmt.Errorf("failed to resolve tangled.sh DID %s: %v", consts.TangledDid, err)

     

       486
       486
       -
       	}

     

       487
       487
       -
       	pdsEndpoint := resolved.PDSEndpoint()

     

       488
       488
       -
       	if pdsEndpoint == "" {

     

       489
       489
       -
       		return nil, fmt.Errorf("no PDS endpoint found for tangled.sh DID %s", consts.TangledDid)

     

       490
       490
       -
       	}

     

       491
       491
       -
       	client := &xrpc.Client{

     

       492
       492
       -
       		Host: pdsEndpoint,

     

       493
       493
       -
       	}

     

       476
       476
       +
       		owner, err := r.ResolveIdent(ctx, atUri.Authority().String())

     

       477
       477
       +
       		if err != nil {

     

       478
       478
       +
       			return nil, fmt.Errorf("failed to resolve default label owner DID %s: %v", atUri.Authority(), err)

     

       479
       479
       +
       		}

     

       494
       480
        
       

     

       495
       495
       -
       	var labelDefs []LabelDefinition

     

       481
       481
       +
       		xrpcc := xrpc.Client{

     

       482
       482
       +
       			Host: owner.PDSEndpoint(),

     

       483
       483
       +
       		}

     

       496
       484
        
       

     

       497
       497
       -
       	for _, dl := range DefaultLabelDefs() {

     

       498
       498
       -
       		atUri := syntax.ATURI(dl)

     

       499
       499
       -
       		parsedUri, err := syntax.ParseATURI(string(atUri))

     

       500
       500
       -
       		if err != nil {

     

       501
       501
       -
       			return nil, fmt.Errorf("failed to parse AT-URI %s: %v", atUri, err)

     

       502
       502
       -
       		}

     

       503
       485
        
       		record, err := atproto.RepoGetRecord(

     

       504
       504
       -
       			context.Background(),

     

       505
       505
       -
       			client,

     

       486
       486
       +
       			ctx,

     

       487
       487
       +
       			&xrpcc,

     

       506
       488
        
       			"",

     

       507
       507
       -
       			parsedUri.Collection().String(),

     

       508
       508
       -
       			parsedUri.Authority().String(),

     

       509
       509
       -
       			parsedUri.RecordKey().String(),

     

       489
       489
       +
       			atUri.Collection().String(),

     

       490
       490
       +
       			atUri.Authority().String(),

     

       491
       491
       +
       			atUri.RecordKey().String(),

     

       510
       492
        
       		)

     

       511
       493
        
       		if err != nil {

     

       512
       494
        
       			return nil, fmt.Errorf("failed to get record for %s: %v", atUri, err)

     
···

       526
       508
        
       			}

     

       527
       509
        
       

     

       528
       510
        
       			labelDef, err := LabelDefinitionFromRecord(

     

       529
       529
       -
       				parsedUri.Authority().String(),

     

       530
       530
       -
       				parsedUri.RecordKey().String(),

     

       511
       511
       +
       				atUri.Authority().String(),

     

       512
       512
       +
       				atUri.RecordKey().String(),

     

       531
       513
        
       				labelRecord,

     

       532
       514
        
       			)

     

       533
       515
        
       			if err != nil {

+17

appview/models/notifications.go

···

       17
       17
        
       	NotificationTypeFollowed       NotificationType = "followed"

     

       18
       18
        
       	NotificationTypePullMerged     NotificationType = "pull_merged"

     

       19
       19
        
       	NotificationTypeIssueClosed    NotificationType = "issue_closed"

     

       20
       20
       +
       	NotificationTypeIssueReopen    NotificationType = "issue_reopen"

     

       20
       21
        
       	NotificationTypePullClosed     NotificationType = "pull_closed"

     

       22
       22
       +
       	NotificationTypePullReopen     NotificationType = "pull_reopen"

     

       23
       23
       +
       	NotificationTypeUserMentioned  NotificationType = "user_mentioned"

     

       21
       24
        
       )

     

       22
       25
        
       

     

       23
       26
        
       type Notification struct {

     
···

       47
       50
        
       		return "message-square"

     

       48
       51
        
       	case NotificationTypeIssueClosed:

     

       49
       52
        
       		return "ban"

     

       53
       53
       +
       	case NotificationTypeIssueReopen:

     

       54
       54
       +
       		return "circle-dot"

     

       50
       55
        
       	case NotificationTypePullCreated:

     

       51
       56
        
       		return "git-pull-request-create"

     

       52
       57
        
       	case NotificationTypePullCommented:

     
···

       55
       60
        
       		return "git-merge"

     

       56
       61
        
       	case NotificationTypePullClosed:

     

       57
       62
        
       		return "git-pull-request-closed"

     

       63
       63
       +
       	case NotificationTypePullReopen:

     

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

     

       58
       65
        
       	case NotificationTypeFollowed:

     

       59
       66
        
       		return "user-plus"

     

       67
       67
       +
       	case NotificationTypeUserMentioned:

     

       68
       68
       +
       		return "at-sign"

     

       60
       69
        
       	default:

     

       61
       70
        
       		return ""

     

       62
       71
        
       	}

     
···

       78
       87
        
       	PullCreated        bool

     

       79
       88
        
       	PullCommented      bool

     

       80
       89
        
       	Followed           bool

     

       90
       90
       +
       	UserMentioned      bool

     

       81
       91
        
       	PullMerged         bool

     

       82
       92
        
       	IssueClosed        bool

     

       83
       93
        
       	EmailNotifications bool

     
···

       93
       103
        
       		return prefs.IssueCommented

     

       94
       104
        
       	case NotificationTypeIssueClosed:

     

       95
       105
        
       		return prefs.IssueClosed

     

       106
       106
       +
       	case NotificationTypeIssueReopen:

     

       107
       107
       +
       		return prefs.IssueCreated // smae pref for now

     

       96
       108
        
       	case NotificationTypePullCreated:

     

       97
       109
        
       		return prefs.PullCreated

     

       98
       110
        
       	case NotificationTypePullCommented:

     
···

       101
       113
        
       		return prefs.PullMerged

     

       102
       114
        
       	case NotificationTypePullClosed:

     

       103
       115
        
       		return prefs.PullMerged // same pref for now

     

       116
       116
       +
       	case NotificationTypePullReopen:

     

       117
       117
       +
       		return prefs.PullCreated // same pref for now

     

       104
       118
        
       	case NotificationTypeFollowed:

     

       105
       119
        
       		return prefs.Followed

     

       120
       120
       +
       	case NotificationTypeUserMentioned:

     

       121
       121
       +
       		return prefs.UserMentioned

     

       106
       122
        
       	default:

     

       107
       123
        
       		return false

     

       108
       124
        
       	}

     
···

       117
       133
        
       		PullCreated:        true,

     

       118
       134
        
       		PullCommented:      true,

     

       119
       135
        
       		Followed:           true,

     

       136
       136
       +
       		UserMentioned:      true,

     

       120
       137
        
       		PullMerged:         true,

     

       121
       138
        
       		IssueClosed:        true,

     

       122
       139
        
       		EmailNotifications: false,

+4 -1

appview/models/profile.go

···

       19
       19
        
       	Links          [5]string

     

       20
       20
        
       	Stats          [2]VanityStat

     

       21
       21
        
       	PinnedRepos    [6]syntax.ATURI

     

       22
       22
       +
       	Pronouns       string

     

       22
       23
        
       }

     

       23
       24
        
       

     

       24
       25
        
       func (p Profile) IsLinksEmpty() bool {

     
···

       110
       111
        
       }

     

       111
       112
        
       

     

       112
       113
        
       type ByMonth struct {

     

       114
       114
       +
       	Commits     int

     

       113
       115
        
       	RepoEvents  []RepoEvent

     

       114
       116
        
       	IssueEvents IssueEvents

     

       115
       117
        
       	PullEvents  PullEvents

     
···

       118
       120
        
       func (b ByMonth) IsEmpty() bool {

     

       119
       121
        
       	return len(b.RepoEvents) == 0 &&

     

       120
       122
        
       		len(b.IssueEvents.Items) == 0 &&

     

       121
       121
       -
       		len(b.PullEvents.Items) == 0

     

       123
       123
       +
       		len(b.PullEvents.Items) == 0 &&

     

       124
       124
       +
       		b.Commits == 0

     

       122
       125
        
       }

     

       123
       126
        
       

     

       124
       127
        
       type IssueEvents struct {

+42 -4

appview/models/pull.go

···

       66
       66
        
       	TargetBranch string

     

       67
       67
        
       	State        PullState

     

       68
       68
        
       	Submissions  []*PullSubmission

     

       69
       69
       +
       	Mentions     []syntax.DID

     

       70
       70
       +
       	References   []syntax.ATURI

     

       69
       71
        
       

     

       70
       72
        
       	// stacking

     

       71
       73
        
       	StackId        string // nullable string

     
···

       92
       94
        
       			source.Repo = &s

     

       93
       95
        
       		}

     

       94
       96
        
       	}

     

       97
       97
       +
       	mentions := make([]string, len(p.Mentions))

     

       98
       98
       +
       	for i, did := range p.Mentions {

     

       99
       99
       +
       		mentions[i] = string(did)

     

       100
       100
       +
       	}

     

       101
       101
       +
       	references := make([]string, len(p.References))

     

       102
       102
       +
       	for i, uri := range p.References {

     

       103
       103
       +
       		references[i] = string(uri)

     

       104
       104
       +
       	}

     

       95
       105
        
       

     

       96
       106
        
       	record := tangled.RepoPull{

     

       97
       97
       -
       		Title:     p.Title,

     

       98
       98
       -
       		Body:      &p.Body,

     

       99
       99
       -
       		CreatedAt: p.Created.Format(time.RFC3339),

     

       107
       107
       +
       		Title:      p.Title,

     

       108
       108
       +
       		Body:       &p.Body,

     

       109
       109
       +
       		Mentions:   mentions,

     

       110
       110
       +
       		References: references,

     

       111
       111
       +
       		CreatedAt:  p.Created.Format(time.RFC3339),

     

       100
       112
        
       		Target: &tangled.RepoPull_Target{

     

       101
       113
        
       			Repo:   p.RepoAt.String(),

     

       102
       114
        
       			Branch: p.TargetBranch,

     
···

       148
       160
        
       	Body string

     

       149
       161
        
       

     

       150
       162
        
       	// meta

     

       163
       163
       +
       	Mentions   []syntax.DID

     

       164
       164
       +
       	References []syntax.ATURI

     

       165
       165
       +
       

     

       166
       166
       +
       	// meta

     

       151
       167
        
       	Created time.Time

     

       152
       168
        
       }

     

       153
       169
        
       

     

       170
       170
       +
       func (p *PullComment) AtUri() syntax.ATURI {

     

       171
       171
       +
       	return syntax.ATURI(p.CommentAt)

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       174
       174
       +
       // func (p *PullComment) AsRecord() tangled.RepoPullComment {

     

       175
       175
       +
       // 	mentions := make([]string, len(p.Mentions))

     

       176
       176
       +
       // 	for i, did := range p.Mentions {

     

       177
       177
       +
       // 		mentions[i] = string(did)

     

       178
       178
       +
       // 	}

     

       179
       179
       +
       // 	references := make([]string, len(p.References))

     

       180
       180
       +
       // 	for i, uri := range p.References {

     

       181
       181
       +
       // 		references[i] = string(uri)

     

       182
       182
       +
       // 	}

     

       183
       183
       +
       // 	return tangled.RepoPullComment{

     

       184
       184
       +
       // 		Pull:       p.PullAt,

     

       185
       185
       +
       // 		Body:       p.Body,

     

       186
       186
       +
       // 		Mentions:   mentions,

     

       187
       187
       +
       // 		References: references,

     

       188
       188
       +
       // 		CreatedAt:  p.Created.Format(time.RFC3339),

     

       189
       189
       +
       // 	}

     

       190
       190
       +
       // }

     

       191
       191
       +
       

     

       154
       192
        
       func (p *Pull) LastRoundNumber() int {

     

       155
       193
        
       	return len(p.Submissions) - 1

     

       156
       194
        
       }

     
···

       167
       205
        
       	return p.LatestSubmission().SourceRev

     

       168
       206
        
       }

     

       169
       207
        
       

     

       170
       170
       -
       func (p *Pull) PullAt() syntax.ATURI {

     

       208
       208
       +
       func (p *Pull) AtUri() syntax.ATURI {

     

       171
       209
        
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey))

     

       172
       210
        
       }

     

       173
       211

+49

appview/models/reference.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import "fmt"

     

       4
       4
       +
       

     

       5
       5
       +
       type RefKind int

     

       6
       6
       +
       

     

       7
       7
       +
       const (

     

       8
       8
       +
       	RefKindIssue RefKind = iota

     

       9
       9
       +
       	RefKindPull

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       func (k RefKind) String() string {

     

       13
       13
       +
       	if k == RefKindIssue {

     

       14
       14
       +
       		return "issues"

     

       15
       15
       +
       	} else {

     

       16
       16
       +
       		return "pulls"

     

       17
       17
       +
       	}

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       // /@alice.com/cool-proj/issues/123

     

       21
       21
       +
       // /@alice.com/cool-proj/issues/123#comment-321

     

       22
       22
       +
       type ReferenceLink struct {

     

       23
       23
       +
       	Handle    string

     

       24
       24
       +
       	Repo      string

     

       25
       25
       +
       	Kind      RefKind

     

       26
       26
       +
       	SubjectId int

     

       27
       27
       +
       	CommentId *int

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func (l ReferenceLink) String() string {

     

       31
       31
       +
       	comment := ""

     

       32
       32
       +
       	if l.CommentId != nil {

     

       33
       33
       +
       		comment = fmt.Sprintf("#comment-%d", *l.CommentId)

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return fmt.Sprintf("/%s/%s/%s/%d%s",

     

       36
       36
       +
       		l.Handle,

     

       37
       37
       +
       		l.Repo,

     

       38
       38
       +
       		l.Kind.String(),

     

       39
       39
       +
       		l.SubjectId,

     

       40
       40
       +
       		comment,

     

       41
       41
       +
       	)

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       type RichReferenceLink struct {

     

       45
       45
       +
       	ReferenceLink

     

       46
       46
       +
       	Title string

     

       47
       47
       +
       	// reusing PullState for both issue & PR

     

       48
       48
       +
       	State PullState

     

       49
       49
       +
       }

+61 -1

appview/models/repo.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
       +
       	"strings"

     

       5
       6
        
       	"time"

     

       6
       7
        
       

     

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

     
···

       17
       18
        
       	Rkey        string

     

       18
       19
        
       	Created     time.Time

     

       19
       20
        
       	Description string

     

       21
       21
       +
       	Website     string

     

       22
       22
       +
       	Topics      []string

     

       20
       23
        
       	Spindle     string

     

       21
       24
        
       	Labels      []string

     

       22
       25
        
       

     
···

       28
       31
        
       }

     

       29
       32
        
       

     

       30
       33
        
       func (r *Repo) AsRecord() tangled.Repo {

     

       31
       31
       -
       	var source, spindle, description *string

     

       34
       34
       +
       	var source, spindle, description, website *string

     

       32
       35
        
       

     

       33
       36
        
       	if r.Source != "" {

     

       34
       37
        
       		source = &r.Source

     
···

       42
       45
        
       		description = &r.Description

     

       43
       46
        
       	}

     

       44
       47
        
       

     

       48
       48
       +
       	if r.Website != "" {

     

       49
       49
       +
       		website = &r.Website

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       45
       52
        
       	return tangled.Repo{

     

       46
       53
        
       		Knot:        r.Knot,

     

       47
       54
        
       		Name:        r.Name,

     

       48
       55
        
       		Description: description,

     

       56
       56
       +
       		Website:     website,

     

       57
       57
       +
       		Topics:      r.Topics,

     

       49
       58
        
       		CreatedAt:   r.Created.Format(time.RFC3339),

     

       50
       59
        
       		Source:      source,

     

       51
       60
        
       		Spindle:     spindle,

     
···

       60
       69
        
       func (r Repo) DidSlashRepo() string {

     

       61
       70
        
       	p, _ := securejoin.SecureJoin(r.Did, r.Name)

     

       62
       71
        
       	return p

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       func (r Repo) TopicStr() string {

     

       75
       75
       +
       	return strings.Join(r.Topics, " ")

     

       63
       76
        
       }

     

       64
       77
        
       

     

       65
       78
        
       type RepoStats struct {

     
···

       91
       104
        
       	Repo   *Repo

     

       92
       105
        
       	Issues []Issue

     

       93
       106
        
       }

     

       107
       107
       +
       

     

       108
       108
       +
       type BlobContentType int

     

       109
       109
       +
       

     

       110
       110
       +
       const (

     

       111
       111
       +
       	BlobContentTypeCode BlobContentType = iota

     

       112
       112
       +
       	BlobContentTypeMarkup

     

       113
       113
       +
       	BlobContentTypeImage

     

       114
       114
       +
       	BlobContentTypeSvg

     

       115
       115
       +
       	BlobContentTypeVideo

     

       116
       116
       +
       	BlobContentTypeSubmodule

     

       117
       117
       +
       )

     

       118
       118
       +
       

     

       119
       119
       +
       func (ty BlobContentType) IsCode() bool      { return ty == BlobContentTypeCode }

     

       120
       120
       +
       func (ty BlobContentType) IsMarkup() bool    { return ty == BlobContentTypeMarkup }

     

       121
       121
       +
       func (ty BlobContentType) IsImage() bool     { return ty == BlobContentTypeImage }

     

       122
       122
       +
       func (ty BlobContentType) IsSvg() bool       { return ty == BlobContentTypeSvg }

     

       123
       123
       +
       func (ty BlobContentType) IsVideo() bool     { return ty == BlobContentTypeVideo }

     

       124
       124
       +
       func (ty BlobContentType) IsSubmodule() bool { return ty == BlobContentTypeSubmodule }

     

       125
       125
       +
       

     

       126
       126
       +
       type BlobView struct {

     

       127
       127
       +
       	HasTextView     bool // can show as code/text

     

       128
       128
       +
       	HasRenderedView bool // can show rendered (markup/image/video/submodule)

     

       129
       129
       +
       	HasRawView      bool // can download raw (everything except submodule)

     

       130
       130
       +
       

     

       131
       131
       +
       	// current display mode

     

       132
       132
       +
       	ShowingRendered bool // currently in rendered mode

     

       133
       133
       +
       	ShowingText     bool // currently in text/code mode

     

       134
       134
       +
       

     

       135
       135
       +
       	// content type flags

     

       136
       136
       +
       	ContentType BlobContentType

     

       137
       137
       +
       

     

       138
       138
       +
       	// Content data

     

       139
       139
       +
       	Contents   string

     

       140
       140
       +
       	ContentSrc string // URL for media files

     

       141
       141
       +
       	Lines      int

     

       142
       142
       +
       	SizeHint   uint64

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       // if both views are available, then show a toggle between them

     

       146
       146
       +
       func (b BlobView) ShowToggle() bool {

     

       147
       147
       +
       	return b.HasTextView && b.HasRenderedView

     

       148
       148
       +
       }

     

       149
       149
       +
       

     

       150
       150
       +
       func (b BlobView) IsUnsupported() bool {

     

       151
       151
       +
       	// no view available, only raw

     

       152
       152
       +
       	return !(b.HasRenderedView || b.HasTextView)

     

       153
       153
       +
       }

+31

appview/models/search.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import "tangled.org/core/appview/pagination"

     

       4
       4
       +
       

     

       5
       5
       +
       type IssueSearchOptions struct {

     

       6
       6
       +
       	Keyword string

     

       7
       7
       +
       	RepoAt  string

     

       8
       8
       +
       	IsOpen  bool

     

       9
       9
       +
       

     

       10
       10
       +
       	Page pagination.Page

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       type PullSearchOptions struct {

     

       14
       14
       +
       	Keyword string

     

       15
       15
       +
       	RepoAt  string

     

       16
       16
       +
       	State   PullState

     

       17
       17
       +
       

     

       18
       18
       +
       	Page pagination.Page

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       // func (so *SearchOptions) ToFilters() []filter {

     

       22
       22
       +
       // 	var filters []filter

     

       23
       23
       +
       // 	if so.IsOpen != nil {

     

       24
       24
       +
       // 		openValue := 0

     

       25
       25
       +
       // 		if *so.IsOpen {

     

       26
       26
       +
       // 			openValue = 1

     

       27
       27
       +
       // 		}

     

       28
       28
       +
       // 		filters = append(filters, FilterEq("open", openValue))

     

       29
       29
       +
       // 	}

     

       30
       30
       +
       // 	return filters

     

       31
       31
       +
       // }

+14 -5

appview/models/star.go

···

       7
       7
        
       )

     

       8
       8
        
       

     

       9
       9
        
       type Star struct {

     

       10
       10
       -
       	StarredByDid string

     

       11
       11
       -
       	RepoAt       syntax.ATURI

     

       12
       12
       -
       	Created      time.Time

     

       13
       13
       -
       	Rkey         string

     

       10
       10
       +
       	Did     string

     

       11
       11
       +
       	RepoAt  syntax.ATURI

     

       12
       12
       +
       	Created time.Time

     

       13
       13
       +
       	Rkey    string

     

       14
       14
       +
       }

     

       14
       15
        
       

     

       15
       15
       -
       	// optionally, populate this when querying for reverse mappings

     

       16
       16
       +
       // RepoStar is used for reverse mapping to repos

     

       17
       17
       +
       type RepoStar struct {

     

       18
       18
       +
       	Star

     

       16
       19
        
       	Repo *Repo

     

       17
       20
        
       }

     

       21
       21
       +
       

     

       22
       22
       +
       // StringStar is used for reverse mapping to strings

     

       23
       23
       +
       type StringStar struct {

     

       24
       24
       +
       	Star

     

       25
       25
       +
       	String *String

     

       26
       26
       +
       }

+1 -1

appview/models/string.go

···

       22
       22
        
       	Edited      *time.Time

     

       23
       23
        
       }

     

       24
       24
        
       

     

       25
       25
       -
       func (s *String) StringAt() syntax.ATURI {

     

       25
       25
       +
       func (s *String) AtUri() syntax.ATURI {

     

       26
       26
        
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", s.Did, tangled.StringNSID, s.Rkey))

     

       27
       27
        
       }

     

       28
       28

+1 -1

appview/models/timeline.go

···

       5
       5
        
       type TimelineEvent struct {

     

       6
       6
        
       	*Repo

     

       7
       7
        
       	*Follow

     

       8
       8
       -
       	*Star

     

       8
       8
       +
       	*RepoStar

     

       9
       9
        
       

     

       10
       10
        
       	EventAt time.Time

     

       11
       11

+6 -9

appview/notifications/notifications.go

···

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

     

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

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       14
       15
        
       )

     

       15
       16
        
       

     

       16
       17
        
       type Notifications struct {

     
···

       49
       50
        
       	l := n.logger.With("handler", "notificationsPage")

     

       50
       51
        
       	user := n.oauth.GetUser(r)

     

       51
       52
        
       

     

       52
       52
       -
       	page, ok := r.Context().Value("page").(pagination.Page)

     

       53
       53
       -
       	if !ok {

     

       54
       54
       -
       		l.Error("failed to get page")

     

       55
       55
       -
       		page = pagination.FirstPage()

     

       56
       56
       -
       	}

     

       53
       53
       +
       	page := pagination.FromContext(r.Context())

     

       57
       54
        
       

     

       58
       55
        
       	total, err := db.CountNotifications(

     

       59
       56
        
       		n.db,

     

       60
       60
       -
       		db.FilterEq("recipient_did", user.Did),

     

       57
       57
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       61
       58
        
       	)

     

       62
       59
        
       	if err != nil {

     

       63
       60
        
       		l.Error("failed to get total notifications", "err", err)

     
···

       68
       65
        
       	notifications, err := db.GetNotificationsWithEntities(

     

       69
       66
        
       		n.db,

     

       70
       67
        
       		page,

     

       71
       71
       -
       		db.FilterEq("recipient_did", user.Did),

     

       68
       68
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       72
       69
        
       	)

     

       73
       70
        
       	if err != nil {

     

       74
       71
        
       		l.Error("failed to get notifications", "err", err)

     
···

       100
       97
        
       

     

       101
       98
        
       	count, err := db.CountNotifications(

     

       102
       99
        
       		n.db,

     

       103
       103
       -
       		db.FilterEq("recipient_did", user.Did),

     

       104
       104
       -
       		db.FilterEq("read", 0),

     

       100
       100
       +
       		orm.FilterEq("recipient_did", user.Did),

     

       101
       101
       +
       		orm.FilterEq("read", 0),

     

       105
       102
        
       	)

     

       106
       103
        
       	if err != nil {

     

       107
       104
        
       		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)

+145 -121

appview/notify/db/db.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"log"

     

       6
       6
       -
       	"maps"

     

       7
       6
        
       	"slices"

     

       8
       7
        
       

     

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

     

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

     

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

     

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

     

       12
       12
        
       	"tangled.org/core/appview/notify"

     

       13
       13
        
       	"tangled.org/core/idresolver"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       15
       15
       +
       	"tangled.org/core/sets"

     

       16
       16
       +
       )

     

       17
       17
       +
       

     

       18
       18
       +
       const (

     

       19
       19
       +
       	maxMentions = 8

     

       14
       20
        
       )

     

       15
       21
        
       

     

       16
       22
        
       type databaseNotifier struct {

     
···

       32
       38
        
       }

     

       33
       39
        
       

     

       34
       40
        
       func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       41
       41
       +
       	if star.RepoAt.Collection().String() != tangled.RepoNSID {

     

       42
       42
       +
       		// skip string stars for now

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       35
       45
        
       	var err error

     

       36
       36
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(star.RepoAt)))

     

       46
       46
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(star.RepoAt)))

     

       37
       47
        
       	if err != nil {

     

       38
       48
        
       		log.Printf("NewStar: failed to get repos: %v", err)

     

       39
       49
        
       		return

     

       40
       50
        
       	}

     

       41
       51
        
       

     

       42
       42
       -
       	actorDid := syntax.DID(star.StarredByDid)

     

       43
       43
       -
       	recipients := []syntax.DID{syntax.DID(repo.Did)}

     

       52
       52
       +
       	actorDid := syntax.DID(star.Did)

     

       53
       53
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       44
       54
        
       	eventType := models.NotificationTypeRepoStarred

     

       45
       55
        
       	entityType := "repo"

     

       46
       56
        
       	entityId := star.RepoAt.String()

     
···

       64
       74
        
       	// no-op

     

       65
       75
        
       }

     

       66
       76
        
       

     

       67
       67
       -
       func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue) {

     

       77
       77
       +
       func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {

     

       78
       78
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       79
       79
       +
       	if err != nil {

     

       80
       80
       +
       		log.Printf("failed to fetch collaborators: %v", err)

     

       81
       81
       +
       		return

     

       82
       82
       +
       	}

     

       68
       83
        
       

     

       69
       84
        
       	// build the recipients list

     

       70
       85
        
       	// - owner of the repo

     

       71
       86
        
       	// - collaborators in the repo

     

       72
       72
       -
       	var recipients []syntax.DID

     

       73
       73
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       74
       74
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       75
       75
       -
       	if err != nil {

     

       76
       76
       -
       		log.Printf("failed to fetch collaborators: %v", err)

     

       77
       77
       -
       		return

     

       87
       87
       +
       	// - remove users already mentioned

     

       88
       88
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       89
       89
       +
       	for _, c := range collaborators {

     

       90
       90
       +
       		recipients.Insert(c.SubjectDid)

     

       78
       91
        
       	}

     

       79
       79
       -
       	for _, c := range collaborators {

     

       80
       80
       -
       		recipients = append(recipients, c.SubjectDid)

     

       92
       92
       +
       	for _, m := range mentions {

     

       93
       93
       +
       		recipients.Remove(m)

     

       81
       94
        
       	}

     

       82
       95
        
       

     

       83
       96
        
       	actorDid := syntax.DID(issue.Did)

     

       84
       84
       -
       	eventType := models.NotificationTypeIssueCreated

     

       85
       97
        
       	entityType := "issue"

     

       86
       98
        
       	entityId := issue.AtUri().String()

     

       87
       99
        
       	repoId := &issue.Repo.Id

     
···

       91
       103
        
       	n.notifyEvent(

     

       92
       104
        
       		actorDid,

     

       93
       105
        
       		recipients,

     

       94
       94
       -
       		eventType,

     

       106
       106
       +
       		models.NotificationTypeIssueCreated,

     

       107
       107
       +
       		entityType,

     

       108
       108
       +
       		entityId,

     

       109
       109
       +
       		repoId,

     

       110
       110
       +
       		issueId,

     

       111
       111
       +
       		pullId,

     

       112
       112
       +
       	)

     

       113
       113
       +
       	n.notifyEvent(

     

       114
       114
       +
       		actorDid,

     

       115
       115
       +
       		sets.Collect(slices.Values(mentions)),

     

       116
       116
       +
       		models.NotificationTypeUserMentioned,

     

       95
       117
        
       		entityType,

     

       96
       118
        
       		entityId,

     

       97
       119
        
       		repoId,

     
···

       100
       122
        
       	)

     

       101
       123
        
       }

     

       102
       124
        
       

     

       103
       103
       -
       func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {

     

       104
       104
       -
       	issues, err := db.GetIssues(n.db, db.FilterEq("at_uri", comment.IssueAt))

     

       125
       125
       +
       func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       126
       126
       +
       	issues, err := db.GetIssues(n.db, orm.FilterEq("at_uri", comment.IssueAt))

     

       105
       127
        
       	if err != nil {

     

       106
       128
        
       		log.Printf("NewIssueComment: failed to get issues: %v", err)

     

       107
       129
        
       		return

     
···

       112
       134
        
       	}

     

       113
       135
        
       	issue := issues[0]

     

       114
       136
        
       

     

       115
       115
       -
       	var recipients []syntax.DID

     

       116
       116
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       137
       137
       +
       	// built the recipients list:

     

       138
       138
       +
       	// - the owner of the repo

     

       139
       139
       +
       	// - | if the comment is a reply -> everybody on that thread

     

       140
       140
       +
       	//   | if the comment is a top level -> just the issue owner

     

       141
       141
       +
       	// - remove mentioned users from the recipients list

     

       142
       142
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       117
       143
        
       

     

       118
       144
        
       	if comment.IsReply() {

     

       119
       145
        
       		// if this comment is a reply, then notify everybody in that thread

     

       120
       146
        
       		parentAtUri := *comment.ReplyTo

     

       121
       121
       -
       		allThreads := issue.CommentList()

     

       122
       147
        
       

     

       123
       148
        
       		// find the parent thread, and add all DIDs from here to the recipient list

     

       124
       124
       -
       		for _, t := range allThreads {

     

       149
       149
       +
       		for _, t := range issue.CommentList() {

     

       125
       150
        
       			if t.Self.AtUri().String() == parentAtUri {

     

       126
       126
       -
       				recipients = append(recipients, t.Participants()...)

     

       151
       151
       +
       				for _, p := range t.Participants() {

     

       152
       152
       +
       					recipients.Insert(p)

     

       153
       153
       +
       				}

     

       127
       154
        
       			}

     

       128
       155
        
       		}

     

       129
       156
        
       	} else {

     

       130
       157
        
       		// not a reply, notify just the issue author

     

       131
       131
       -
       		recipients = append(recipients, syntax.DID(issue.Did))

     

       158
       158
       +
       		recipients.Insert(syntax.DID(issue.Did))

     

       159
       159
       +
       	}

     

       160
       160
       +
       

     

       161
       161
       +
       	for _, m := range mentions {

     

       162
       162
       +
       		recipients.Remove(m)

     

       132
       163
        
       	}

     

       133
       164
        
       

     

       134
       165
        
       	actorDid := syntax.DID(comment.Did)

     

       135
       135
       -
       	eventType := models.NotificationTypeIssueCommented

     

       136
       166
        
       	entityType := "issue"

     

       137
       167
        
       	entityId := issue.AtUri().String()

     

       138
       168
        
       	repoId := &issue.Repo.Id

     
···

       142
       172
        
       	n.notifyEvent(

     

       143
       173
        
       		actorDid,

     

       144
       174
        
       		recipients,

     

       145
       145
       -
       		eventType,

     

       175
       175
       +
       		models.NotificationTypeIssueCommented,

     

       176
       176
       +
       		entityType,

     

       177
       177
       +
       		entityId,

     

       178
       178
       +
       		repoId,

     

       179
       179
       +
       		issueId,

     

       180
       180
       +
       		pullId,

     

       181
       181
       +
       	)

     

       182
       182
       +
       	n.notifyEvent(

     

       183
       183
       +
       		actorDid,

     

       184
       184
       +
       		sets.Collect(slices.Values(mentions)),

     

       185
       185
       +
       		models.NotificationTypeUserMentioned,

     

       146
       186
        
       		entityType,

     

       147
       187
        
       		entityId,

     

       148
       188
        
       		repoId,

     
···

       151
       191
        
       	)

     

       152
       192
        
       }

     

       153
       193
        
       

     

       194
       194
       +
       func (n *databaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue) {

     

       195
       195
       +
       	// no-op for now

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       154
       198
        
       func (n *databaseNotifier) NewFollow(ctx context.Context, follow *models.Follow) {

     

       155
       199
        
       	actorDid := syntax.DID(follow.UserDid)

     

       156
       156
       -
       	recipients := []syntax.DID{syntax.DID(follow.SubjectDid)}

     

       200
       200
       +
       	recipients := sets.Singleton(syntax.DID(follow.SubjectDid))

     

       157
       201
        
       	eventType := models.NotificationTypeFollowed

     

       158
       202
        
       	entityType := "follow"

     

       159
       203
        
       	entityId := follow.UserDid

     
···

       176
       220
        
       }

     

       177
       221
        
       

     

       178
       222
        
       func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {

     

       179
       179
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       223
       223
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))

     

       180
       224
        
       	if err != nil {

     

       181
       225
        
       		log.Printf("NewPull: failed to get repos: %v", err)

     

       182
       226
        
       		return

     

       183
       227
        
       	}

     

       184
       184
       -
       

     

       185
       185
       -
       	// build the recipients list

     

       186
       186
       -
       	// - owner of the repo

     

       187
       187
       -
       	// - collaborators in the repo

     

       188
       188
       -
       	var recipients []syntax.DID

     

       189
       189
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       190
       190
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       228
       228
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))

     

       191
       229
        
       	if err != nil {

     

       192
       230
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       193
       231
        
       		return

     

       194
       232
        
       	}

     

       233
       233
       +
       

     

       234
       234
       +
       	// build the recipients list

     

       235
       235
       +
       	// - owner of the repo

     

       236
       236
       +
       	// - collaborators in the repo

     

       237
       237
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       195
       238
        
       	for _, c := range collaborators {

     

       196
       196
       -
       		recipients = append(recipients, c.SubjectDid)

     

       239
       239
       +
       		recipients.Insert(c.SubjectDid)

     

       197
       240
        
       	}

     

       198
       241
        
       

     

       199
       242
        
       	actorDid := syntax.DID(pull.OwnerDid)

     

       200
       243
        
       	eventType := models.NotificationTypePullCreated

     

       201
       244
        
       	entityType := "pull"

     

       202
       202
       -
       	entityId := pull.PullAt().String()

     

       245
       245
       +
       	entityId := pull.AtUri().String()

     

       203
       246
        
       	repoId := &repo.Id

     

       204
       247
        
       	var issueId *int64

     

       205
       248
        
       	p := int64(pull.ID)

     
···

       217
       260
        
       	)

     

       218
       261
        
       }

     

       219
       262
        
       

     

       220
       220
       -
       func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment) {

     

       263
       263
       +
       func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {

     

       221
       264
        
       	pull, err := db.GetPull(n.db,

     

       222
       265
        
       		syntax.ATURI(comment.RepoAt),

     

       223
       266
        
       		comment.PullId,

     
···

       227
       270
        
       		return

     

       228
       271
        
       	}

     

       229
       272
        
       

     

       230
       230
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", comment.RepoAt))

     

       273
       273
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", comment.RepoAt))

     

       231
       274
        
       	if err != nil {

     

       232
       275
        
       		log.Printf("NewPullComment: failed to get repos: %v", err)

     

       233
       276
        
       		return

     
···

       236
       279
        
       	// build up the recipients list:

     

       237
       280
        
       	// - repo owner

     

       238
       281
        
       	// - all pull participants

     

       239
       239
       -
       	var recipients []syntax.DID

     

       240
       240
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       282
       282
       +
       	// - remove those already mentioned

     

       283
       283
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       241
       284
        
       	for _, p := range pull.Participants() {

     

       242
       242
       -
       		recipients = append(recipients, syntax.DID(p))

     

       285
       285
       +
       		recipients.Insert(syntax.DID(p))

     

       286
       286
       +
       	}

     

       287
       287
       +
       	for _, m := range mentions {

     

       288
       288
       +
       		recipients.Remove(m)

     

       243
       289
        
       	}

     

       244
       290
        
       

     

       245
       291
        
       	actorDid := syntax.DID(comment.OwnerDid)

     

       246
       292
        
       	eventType := models.NotificationTypePullCommented

     

       247
       293
        
       	entityType := "pull"

     

       248
       248
       -
       	entityId := pull.PullAt().String()

     

       294
       294
       +
       	entityId := pull.AtUri().String()

     

       249
       295
        
       	repoId := &repo.Id

     

       250
       296
        
       	var issueId *int64

     

       251
       297
        
       	p := int64(pull.ID)

     
···

       261
       307
        
       		issueId,

     

       262
       308
        
       		pullId,

     

       263
       309
        
       	)

     

       310
       310
       +
       	n.notifyEvent(

     

       311
       311
       +
       		actorDid,

     

       312
       312
       +
       		sets.Collect(slices.Values(mentions)),

     

       313
       313
       +
       		models.NotificationTypeUserMentioned,

     

       314
       314
       +
       		entityType,

     

       315
       315
       +
       		entityId,

     

       316
       316
       +
       		repoId,

     

       317
       317
       +
       		issueId,

     

       318
       318
       +
       		pullId,

     

       319
       319
       +
       	)

     

       264
       320
        
       }

     

       265
       321
        
       

     

       266
       322
        
       func (n *databaseNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {

     
···

       279
       335
        
       	// no-op

     

       280
       336
        
       }

     

       281
       337
        
       

     

       282
       282
       -
       func (n *databaseNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       283
       283
       -
       	// build up the recipients list:

     

       284
       284
       -
       	// - repo owner

     

       285
       285
       -
       	// - repo collaborators

     

       286
       286
       -
       	// - all issue participants

     

       287
       287
       -
       	var recipients []syntax.DID

     

       288
       288
       -
       	recipients = append(recipients, syntax.DID(issue.Repo.Did))

     

       289
       289
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       338
       338
       +
       func (n *databaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

     

       339
       339
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", issue.Repo.RepoAt()))

     

       290
       340
        
       	if err != nil {

     

       291
       341
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       292
       342
        
       		return

     

       293
       343
        
       	}

     

       344
       344
       +
       

     

       345
       345
       +
       	// build up the recipients list:

     

       346
       346
       +
       	// - repo owner

     

       347
       347
       +
       	// - repo collaborators

     

       348
       348
       +
       	// - all issue participants

     

       349
       349
       +
       	recipients := sets.Singleton(syntax.DID(issue.Repo.Did))

     

       294
       350
        
       	for _, c := range collaborators {

     

       295
       295
       -
       		recipients = append(recipients, c.SubjectDid)

     

       351
       351
       +
       		recipients.Insert(c.SubjectDid)

     

       296
       352
        
       	}

     

       297
       353
        
       	for _, p := range issue.Participants() {

     

       298
       298
       -
       		recipients = append(recipients, syntax.DID(p))

     

       354
       354
       +
       		recipients.Insert(syntax.DID(p))

     

       299
       355
        
       	}

     

       300
       356
        
       

     

       301
       301
       -
       	actorDid := syntax.DID(issue.Repo.Did)

     

       302
       302
       -
       	eventType := models.NotificationTypeIssueClosed

     

       303
       357
        
       	entityType := "pull"

     

       304
       358
        
       	entityId := issue.AtUri().String()

     

       305
       359
        
       	repoId := &issue.Repo.Id

     

       306
       360
        
       	issueId := &issue.Id

     

       307
       361
        
       	var pullId *int64

     

       362
       362
       +
       	var eventType models.NotificationType

     

       363
       363
       +
       

     

       364
       364
       +
       	if issue.Open {

     

       365
       365
       +
       		eventType = models.NotificationTypeIssueReopen

     

       366
       366
       +
       	} else {

     

       367
       367
       +
       		eventType = models.NotificationTypeIssueClosed

     

       368
       368
       +
       	}

     

       308
       369
        
       

     

       309
       370
        
       	n.notifyEvent(

     

       310
       310
       -
       		actorDid,

     

       371
       371
       +
       		actor,

     

       311
       372
        
       		recipients,

     

       312
       373
        
       		eventType,

     

       313
       374
        
       		entityType,

     
···

       318
       379
        
       	)

     

       319
       380
        
       }

     

       320
       381
        
       

     

       321
       321
       -
       func (n *databaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       382
       382
       +
       func (n *databaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

     

       322
       383
        
       	// Get repo details

     

       323
       323
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       384
       384
       +
       	repo, err := db.GetRepo(n.db, orm.FilterEq("at_uri", string(pull.RepoAt)))

     

       324
       385
        
       	if err != nil {

     

       325
       325
       -
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       386
       386
       +
       		log.Printf("NewPullState: failed to get repos: %v", err)

     

       326
       387
        
       		return

     

       327
       388
        
       	}

     

       328
       389
        
       

     

       329
       329
       -
       	// build up the recipients list:

     

       330
       330
       -
       	// - repo owner

     

       331
       331
       -
       	// - all pull participants

     

       332
       332
       -
       	var recipients []syntax.DID

     

       333
       333
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       334
       334
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       390
       390
       +
       	collaborators, err := db.GetCollaborators(n.db, orm.FilterEq("repo_at", repo.RepoAt()))

     

       335
       391
        
       	if err != nil {

     

       336
       392
        
       		log.Printf("failed to fetch collaborators: %v", err)

     

       337
       393
        
       		return

     

       338
       394
        
       	}

     

       339
       339
       -
       	for _, c := range collaborators {

     

       340
       340
       -
       		recipients = append(recipients, c.SubjectDid)

     

       341
       341
       -
       	}

     

       342
       342
       -
       	for _, p := range pull.Participants() {

     

       343
       343
       -
       		recipients = append(recipients, syntax.DID(p))

     

       344
       344
       -
       	}

     

       345
       345
       -
       

     

       346
       346
       -
       	actorDid := syntax.DID(repo.Did)

     

       347
       347
       -
       	eventType := models.NotificationTypePullMerged

     

       348
       348
       -
       	entityType := "pull"

     

       349
       349
       -
       	entityId := pull.PullAt().String()

     

       350
       350
       -
       	repoId := &repo.Id

     

       351
       351
       -
       	var issueId *int64

     

       352
       352
       -
       	p := int64(pull.ID)

     

       353
       353
       -
       	pullId := &p

     

       354
       354
       -
       

     

       355
       355
       -
       	n.notifyEvent(

     

       356
       356
       -
       		actorDid,

     

       357
       357
       -
       		recipients,

     

       358
       358
       -
       		eventType,

     

       359
       359
       -
       		entityType,

     

       360
       360
       -
       		entityId,

     

       361
       361
       -
       		repoId,

     

       362
       362
       -
       		issueId,

     

       363
       363
       -
       		pullId,

     

       364
       364
       -
       	)

     

       365
       365
       -
       }

     

       366
       366
       -
       

     

       367
       367
       -
       func (n *databaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       368
       368
       -
       	// Get repo details

     

       369
       369
       -
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       370
       370
       -
       	if err != nil {

     

       371
       371
       -
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       372
       372
       -
       		return

     

       373
       373
       -
       	}

     

       374
       395
        
       

     

       375
       396
        
       	// build up the recipients list:

     

       376
       397
        
       	// - repo owner

     

       377
       398
        
       	// - all pull participants

     

       378
       378
       -
       	var recipients []syntax.DID

     

       379
       379
       -
       	recipients = append(recipients, syntax.DID(repo.Did))

     

       380
       380
       -
       	collaborators, err := db.GetCollaborators(n.db, db.FilterEq("repo_at", repo.RepoAt()))

     

       381
       381
       -
       	if err != nil {

     

       382
       382
       -
       		log.Printf("failed to fetch collaborators: %v", err)

     

       383
       383
       -
       		return

     

       384
       384
       -
       	}

     

       399
       399
       +
       	recipients := sets.Singleton(syntax.DID(repo.Did))

     

       385
       400
        
       	for _, c := range collaborators {

     

       386
       386
       -
       		recipients = append(recipients, c.SubjectDid)

     

       401
       401
       +
       		recipients.Insert(c.SubjectDid)

     

       387
       402
        
       	}

     

       388
       403
        
       	for _, p := range pull.Participants() {

     

       389
       389
       -
       		recipients = append(recipients, syntax.DID(p))

     

       404
       404
       +
       		recipients.Insert(syntax.DID(p))

     

       390
       405
        
       	}

     

       391
       406
        
       

     

       392
       392
       -
       	actorDid := syntax.DID(repo.Did)

     

       393
       393
       -
       	eventType := models.NotificationTypePullClosed

     

       394
       407
        
       	entityType := "pull"

     

       395
       395
       -
       	entityId := pull.PullAt().String()

     

       408
       408
       +
       	entityId := pull.AtUri().String()

     

       396
       409
        
       	repoId := &repo.Id

     

       397
       410
        
       	var issueId *int64

     

       411
       411
       +
       	var eventType models.NotificationType

     

       412
       412
       +
       	switch pull.State {

     

       413
       413
       +
       	case models.PullClosed:

     

       414
       414
       +
       		eventType = models.NotificationTypePullClosed

     

       415
       415
       +
       	case models.PullOpen:

     

       416
       416
       +
       		eventType = models.NotificationTypePullReopen

     

       417
       417
       +
       	case models.PullMerged:

     

       418
       418
       +
       		eventType = models.NotificationTypePullMerged

     

       419
       419
       +
       	default:

     

       420
       420
       +
       		log.Println("NewPullState: unexpected new PR state:", pull.State)

     

       421
       421
       +
       		return

     

       422
       422
       +
       	}

     

       398
       423
        
       	p := int64(pull.ID)

     

       399
       424
        
       	pullId := &p

     

       400
       425
        
       

     

       401
       426
        
       	n.notifyEvent(

     

       402
       402
       -
       		actorDid,

     

       427
       427
       +
       		actor,

     

       403
       428
        
       		recipients,

     

       404
       429
        
       		eventType,

     

       405
       430
        
       		entityType,

     
···

       412
       437
        
       

     

       413
       438
        
       func (n *databaseNotifier) notifyEvent(

     

       414
       439
        
       	actorDid syntax.DID,

     

       415
       415
       -
       	recipients []syntax.DID,

     

       440
       440
       +
       	recipients sets.Set[syntax.DID],

     

       416
       441
        
       	eventType models.NotificationType,

     

       417
       442
        
       	entityType string,

     

       418
       443
        
       	entityId string,

     
···

       420
       445
        
       	issueId *int64,

     

       421
       446
        
       	pullId *int64,

     

       422
       447
        
       ) {

     

       423
       423
       -
       	recipientSet := make(map[syntax.DID]struct{})

     

       424
       424
       -
       	for _, did := range recipients {

     

       425
       425
       -
       		// everybody except actor themselves

     

       426
       426
       -
       		if did != actorDid {

     

       427
       427
       -
       			recipientSet[did] = struct{}{}

     

       428
       428
       -
       		}

     

       448
       448
       +
       	// if the user is attempting to mention >maxMentions users, this is probably spam, do not mention anybody

     

       449
       449
       +
       	if eventType == models.NotificationTypeUserMentioned && recipients.Len() > maxMentions {

     

       450
       450
       +
       		return

     

       429
       451
        
       	}

     

       430
       452
        
       

     

       453
       453
       +
       	recipients.Remove(actorDid)

     

       454
       454
       +
       

     

       431
       455
        
       	prefMap, err := db.GetNotificationPreferences(

     

       432
       456
        
       		n.db,

     

       433
       433
       -
       		db.FilterIn("user_did", slices.Collect(maps.Keys(recipientSet))),

     

       457
       457
       +
       		orm.FilterIn("user_did", slices.Collect(recipients.All())),

     

       434
       458
        
       	)

     

       435
       459
        
       	if err != nil {

     

       436
       460
        
       		// failed to get prefs for users

     
···

       446
       470
        
       	defer tx.Rollback()

     

       447
       471
        
       

     

       448
       472
        
       	// filter based on preferences

     

       449
       449
       -
       	for recipientDid := range recipientSet {

     

       473
       473
       +
       	for recipientDid := range recipients.All() {

     

       450
       474
        
       		prefs, ok := prefMap[recipientDid]

     

       451
       475
        
       		if !ok {

     

       452
       476
        
       			prefs = models.DefaultNotificationPreferences(recipientDid)

+57 -59

appview/notify/merged_notifier.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       6
       6
       +
       	"reflect"

     

       7
       7
       +
       	"sync"

     

       5
       8
        
       

     

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

     

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

     

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

     

       7
       12
        
       )

     

       8
       13
        
       

     

       9
       14
        
       type mergedNotifier struct {

     

       10
       15
        
       	notifiers []Notifier

     

       16
       16
       +
       	logger    *slog.Logger

     

       11
       17
        
       }

     

       12
       18
        
       

     

       13
       13
       -
       func NewMergedNotifier(notifiers ...Notifier) Notifier {

     

       14
       14
       -
       	return &mergedNotifier{notifiers}

     

       19
       19
       +
       func NewMergedNotifier(notifiers []Notifier, logger *slog.Logger) Notifier {

     

       20
       20
       +
       	return &mergedNotifier{notifiers, logger}

     

       15
       21
        
       }

     

       16
       22
        
       

     

       17
       23
        
       var _ Notifier = &mergedNotifier{}

     

       18
       24
        
       

     

       19
       19
       -
       func (m *mergedNotifier) NewRepo(ctx context.Context, repo *models.Repo) {

     

       20
       20
       -
       	for _, notifier := range m.notifiers {

     

       21
       21
       -
       		notifier.NewRepo(ctx, repo)

     

       25
       25
       +
       // fanout calls the same method on all notifiers concurrently

     

       26
       26
       +
       func (m *mergedNotifier) fanout(method string, ctx context.Context, args ...any) {

     

       27
       27
       +
       	ctx = log.IntoContext(ctx, m.logger.With("method", method))

     

       28
       28
       +
       	var wg sync.WaitGroup

     

       29
       29
       +
       	for _, n := range m.notifiers {

     

       30
       30
       +
       		wg.Add(1)

     

       31
       31
       +
       		go func(notifier Notifier) {

     

       32
       32
       +
       			defer wg.Done()

     

       33
       33
       +
       			v := reflect.ValueOf(notifier).MethodByName(method)

     

       34
       34
       +
       			in := make([]reflect.Value, len(args)+1)

     

       35
       35
       +
       			in[0] = reflect.ValueOf(ctx)

     

       36
       36
       +
       			for i, arg := range args {

     

       37
       37
       +
       				in[i+1] = reflect.ValueOf(arg)

     

       38
       38
       +
       			}

     

       39
       39
       +
       			v.Call(in)

     

       40
       40
       +
       		}(n)

     

       22
       41
        
       	}

     

       42
       42
       +
       	wg.Wait()

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       func (m *mergedNotifier) NewRepo(ctx context.Context, repo *models.Repo) {

     

       46
       46
       +
       	m.fanout("NewRepo", ctx, repo)

     

       23
       47
        
       }

     

       24
       48
        
       

     

       25
       49
        
       func (m *mergedNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       26
       26
       -
       	for _, notifier := range m.notifiers {

     

       27
       27
       -
       		notifier.NewStar(ctx, star)

     

       28
       28
       -
       	}

     

       50
       50
       +
       	m.fanout("NewStar", ctx, star)

     

       29
       51
        
       }

     

       52
       52
       +
       

     

       30
       53
        
       func (m *mergedNotifier) DeleteStar(ctx context.Context, star *models.Star) {

     

       31
       31
       -
       	for _, notifier := range m.notifiers {

     

       32
       32
       -
       		notifier.DeleteStar(ctx, star)

     

       33
       33
       -
       	}

     

       54
       54
       +
       	m.fanout("DeleteStar", ctx, star)

     

       34
       55
        
       }

     

       35
       56
        
       

     

       36
       36
       -
       func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue) {

     

       37
       37
       -
       	for _, notifier := range m.notifiers {

     

       38
       38
       -
       		notifier.NewIssue(ctx, issue)

     

       39
       39
       -
       	}

     

       57
       57
       +
       func (m *mergedNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {

     

       58
       58
       +
       	m.fanout("NewIssue", ctx, issue, mentions)

     

       40
       59
        
       }

     

       41
       41
       -
       func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {

     

       42
       42
       -
       	for _, notifier := range m.notifiers {

     

       43
       43
       -
       		notifier.NewIssueComment(ctx, comment)

     

       44
       44
       -
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       62
       62
       +
       	m.fanout("NewIssueComment", ctx, comment, mentions)

     

       45
       63
        
       }

     

       46
       64
        
       

     

       47
       47
       -
       func (m *mergedNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       48
       48
       -
       	for _, notifier := range m.notifiers {

     

       49
       49
       -
       		notifier.NewIssueClosed(ctx, issue)

     

       50
       50
       -
       	}

     

       65
       65
       +
       func (m *mergedNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

     

       66
       66
       +
       	m.fanout("NewIssueState", ctx, actor, issue)

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       func (m *mergedNotifier) DeleteIssue(ctx context.Context, issue *models.Issue) {

     

       70
       70
       +
       	m.fanout("DeleteIssue", ctx, issue)

     

       51
       71
        
       }

     

       52
       72
        
       

     

       53
       73
        
       func (m *mergedNotifier) NewFollow(ctx context.Context, follow *models.Follow) {

     

       54
       54
       -
       	for _, notifier := range m.notifiers {

     

       55
       55
       -
       		notifier.NewFollow(ctx, follow)

     

       56
       56
       -
       	}

     

       74
       74
       +
       	m.fanout("NewFollow", ctx, follow)

     

       57
       75
        
       }

     

       76
       76
       +
       

     

       58
       77
        
       func (m *mergedNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {

     

       59
       59
       -
       	for _, notifier := range m.notifiers {

     

       60
       60
       -
       		notifier.DeleteFollow(ctx, follow)

     

       61
       61
       -
       	}

     

       78
       78
       +
       	m.fanout("DeleteFollow", ctx, follow)

     

       62
       79
        
       }

     

       63
       80
        
       

     

       64
       81
        
       func (m *mergedNotifier) NewPull(ctx context.Context, pull *models.Pull) {

     

       65
       65
       -
       	for _, notifier := range m.notifiers {

     

       66
       66
       -
       		notifier.NewPull(ctx, pull)

     

       67
       67
       -
       	}

     

       68
       68
       -
       }

     

       69
       69
       -
       func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.PullComment) {

     

       70
       70
       -
       	for _, notifier := range m.notifiers {

     

       71
       71
       -
       		notifier.NewPullComment(ctx, comment)

     

       72
       72
       -
       	}

     

       82
       82
       +
       	m.fanout("NewPull", ctx, pull)

     

       73
       83
        
       }

     

       74
       84
        
       

     

       75
       75
       -
       func (m *mergedNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       76
       76
       -
       	for _, notifier := range m.notifiers {

     

       77
       77
       -
       		notifier.NewPullMerged(ctx, pull)

     

       78
       78
       -
       	}

     

       85
       85
       +
       func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {

     

       86
       86
       +
       	m.fanout("NewPullComment", ctx, comment, mentions)

     

       79
       87
        
       }

     

       80
       88
        
       

     

       81
       81
       -
       func (m *mergedNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       82
       82
       -
       	for _, notifier := range m.notifiers {

     

       83
       83
       -
       		notifier.NewPullClosed(ctx, pull)

     

       84
       84
       -
       	}

     

       89
       89
       +
       func (m *mergedNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

     

       90
       90
       +
       	m.fanout("NewPullState", ctx, actor, pull)

     

       85
       91
        
       }

     

       86
       92
        
       

     

       87
       93
        
       func (m *mergedNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {

     

       88
       88
       -
       	for _, notifier := range m.notifiers {

     

       89
       89
       -
       		notifier.UpdateProfile(ctx, profile)

     

       90
       90
       -
       	}

     

       94
       94
       +
       	m.fanout("UpdateProfile", ctx, profile)

     

       91
       95
        
       }

     

       92
       96
        
       

     

       93
       93
       -
       func (m *mergedNotifier) NewString(ctx context.Context, string *models.String) {

     

       94
       94
       -
       	for _, notifier := range m.notifiers {

     

       95
       95
       -
       		notifier.NewString(ctx, string)

     

       96
       96
       -
       	}

     

       97
       97
       +
       func (m *mergedNotifier) NewString(ctx context.Context, s *models.String) {

     

       98
       98
       +
       	m.fanout("NewString", ctx, s)

     

       97
       99
        
       }

     

       98
       100
        
       

     

       99
       99
       -
       func (m *mergedNotifier) EditString(ctx context.Context, string *models.String) {

     

       100
       100
       -
       	for _, notifier := range m.notifiers {

     

       101
       101
       -
       		notifier.EditString(ctx, string)

     

       102
       102
       -
       	}

     

       101
       101
       +
       func (m *mergedNotifier) EditString(ctx context.Context, s *models.String) {

     

       102
       102
       +
       	m.fanout("EditString", ctx, s)

     

       103
       103
        
       }

     

       104
       104
        
       

     

       105
       105
        
       func (m *mergedNotifier) DeleteString(ctx context.Context, did, rkey string) {

     

       106
       106
       -
       	for _, notifier := range m.notifiers {

     

       107
       107
       -
       		notifier.DeleteString(ctx, did, rkey)

     

       108
       108
       -
       	}

     

       106
       106
       +
       	m.fanout("DeleteString", ctx, did, rkey)

     

       109
       107
        
       }

+16 -13

appview/notify/notifier.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       

     

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

     

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

     

       7
       8
        
       )

     

       8
       9
        
       

     
···

       12
       13
        
       	NewStar(ctx context.Context, star *models.Star)

     

       13
       14
        
       	DeleteStar(ctx context.Context, star *models.Star)

     

       14
       15
        
       

     

       15
       15
       -
       	NewIssue(ctx context.Context, issue *models.Issue)

     

       16
       16
       -
       	NewIssueComment(ctx context.Context, comment *models.IssueComment)

     

       17
       17
       -
       	NewIssueClosed(ctx context.Context, issue *models.Issue)

     

       16
       16
       +
       	NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID)

     

       17
       17
       +
       	NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID)

     

       18
       18
       +
       	NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue)

     

       19
       19
       +
       	DeleteIssue(ctx context.Context, issue *models.Issue)

     

       18
       20
        
       

     

       19
       21
        
       	NewFollow(ctx context.Context, follow *models.Follow)

     

       20
       22
        
       	DeleteFollow(ctx context.Context, follow *models.Follow)

     

       21
       23
        
       

     

       22
       24
        
       	NewPull(ctx context.Context, pull *models.Pull)

     

       23
       23
       -
       	NewPullComment(ctx context.Context, comment *models.PullComment)

     

       24
       24
       -
       	NewPullMerged(ctx context.Context, pull *models.Pull)

     

       25
       25
       -
       	NewPullClosed(ctx context.Context, pull *models.Pull)

     

       25
       25
       +
       	NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID)

     

       26
       26
       +
       	NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull)

     

       26
       27
        
       

     

       27
       28
        
       	UpdateProfile(ctx context.Context, profile *models.Profile)

     

       28
       29
        
       

     
···

       41
       42
        
       func (m *BaseNotifier) NewStar(ctx context.Context, star *models.Star)    {}

     

       42
       43
        
       func (m *BaseNotifier) DeleteStar(ctx context.Context, star *models.Star) {}

     

       43
       44
        
       

     

       44
       44
       -
       func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue)                 {}

     

       45
       45
       -
       func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {}

     

       46
       46
       -
       func (m *BaseNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue)           {}

     

       45
       45
       +
       func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {}

     

       46
       46
       +
       func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       47
       47
       +
       }

     

       48
       48
       +
       func (m *BaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {}

     

       49
       49
       +
       func (m *BaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue)                     {}

     

       47
       50
        
       

     

       48
       51
        
       func (m *BaseNotifier) NewFollow(ctx context.Context, follow *models.Follow)    {}

     

       49
       52
        
       func (m *BaseNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {}

     

       50
       53
        
       

     

       51
       51
       -
       func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull)                 {}

     

       52
       52
       -
       func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment) {}

     

       53
       53
       -
       func (m *BaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull)           {}

     

       54
       54
       -
       func (m *BaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull)           {}

     

       54
       54
       +
       func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {}

     

       55
       55
       +
       func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment, mentions []syntax.DID) {

     

       56
       56
       +
       }

     

       57
       57
       +
       func (m *BaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {}

     

       55
       58
        
       

     

       56
       59
        
       func (m *BaseNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {}

     

       57
       60

+35 -11

appview/notify/posthog/notifier.go

···

       4
       4
        
       	"context"

     

       5
       5
        
       	"log"

     

       6
       6
        
       

     

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

     

       7
       8
        
       	"github.com/posthog/posthog-go"

     

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

     

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

     
···

       36
       37
        
       

     

       37
       38
        
       func (n *posthogNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       38
       39
        
       	err := n.client.Enqueue(posthog.Capture{

     

       39
       39
       -
       		DistinctId: star.StarredByDid,

     

       40
       40
       +
       		DistinctId: star.Did,

     

       40
       41
        
       		Event:      "star",

     

       41
       42
        
       		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},

     

       42
       43
        
       	})

     
···

       47
       48
        
       

     

       48
       49
        
       func (n *posthogNotifier) DeleteStar(ctx context.Context, star *models.Star) {

     

       49
       50
        
       	err := n.client.Enqueue(posthog.Capture{

     

       50
       50
       -
       		DistinctId: star.StarredByDid,

     

       51
       51
       +
       		DistinctId: star.Did,

     

       51
       52
        
       		Event:      "unstar",

     

       52
       53
        
       		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},

     

       53
       54
        
       	})

     
···

       56
       57
        
       	}

     

       57
       58
        
       }

     

       58
       59
        
       

     

       59
       59
       -
       func (n *posthogNotifier) NewIssue(ctx context.Context, issue *models.Issue) {

     

       60
       60
       +
       func (n *posthogNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {

     

       60
       61
        
       	err := n.client.Enqueue(posthog.Capture{

     

       61
       62
        
       		DistinctId: issue.Did,

     

       62
       63
        
       		Event:      "new_issue",

     

       63
       64
        
       		Properties: posthog.Properties{

     

       64
       65
        
       			"repo_at":  issue.RepoAt.String(),

     

       65
       66
        
       			"issue_id": issue.IssueId,

     

       67
       67
       +
       			"mentions": mentions,

     

       66
       68
        
       		},

     

       67
       69
        
       	})

     

       68
       70
        
       	if err != nil {

     
···

       84
       86
        
       	}

     

       85
       87
        
       }

     

       86
       88
        
       

     

       87
       87
       -
       func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.PullComment) {

     

       89
       89
       +
       func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) {

     

       88
       90
        
       	err := n.client.Enqueue(posthog.Capture{

     

       89
       91
        
       		DistinctId: comment.OwnerDid,

     

       90
       92
        
       		Event:      "new_pull_comment",

     

       91
       93
        
       		Properties: posthog.Properties{

     

       92
       92
       -
       			"repo_at": comment.RepoAt,

     

       93
       93
       -
       			"pull_id": comment.PullId,

     

       94
       94
       +
       			"repo_at":  comment.RepoAt,

     

       95
       95
       +
       			"pull_id":  comment.PullId,

     

       96
       96
       +
       			"mentions": mentions,

     

       94
       97
        
       		},

     

       95
       98
        
       	})

     

       96
       99
        
       	if err != nil {

     
···

       177
       180
        
       	}

     

       178
       181
        
       }

     

       179
       182
        
       

     

       180
       180
       -
       func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {

     

       183
       183
       +
       func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       181
       184
        
       	err := n.client.Enqueue(posthog.Capture{

     

       182
       185
        
       		DistinctId: comment.Did,

     

       183
       186
        
       		Event:      "new_issue_comment",

     

       184
       187
        
       		Properties: posthog.Properties{

     

       185
       188
        
       			"issue_at": comment.IssueAt,

     

       189
       189
       +
       			"mentions": mentions,

     

       186
       190
        
       		},

     

       187
       191
        
       	})

     

       188
       192
        
       	if err != nil {

     
···

       190
       194
        
       	}

     

       191
       195
        
       }

     

       192
       196
        
       

     

       193
       193
       -
       func (n *posthogNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       197
       197
       +
       func (n *posthogNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {

     

       198
       198
       +
       	var event string

     

       199
       199
       +
       	if issue.Open {

     

       200
       200
       +
       		event = "issue_reopen"

     

       201
       201
       +
       	} else {

     

       202
       202
       +
       		event = "issue_closed"

     

       203
       203
       +
       	}

     

       194
       204
        
       	err := n.client.Enqueue(posthog.Capture{

     

       195
       205
        
       		DistinctId: issue.Did,

     

       196
       196
       -
       		Event:      "issue_closed",

     

       206
       206
       +
       		Event:      event,

     

       197
       207
        
       		Properties: posthog.Properties{

     

       198
       208
        
       			"repo_at":  issue.RepoAt.String(),

     

       209
       209
       +
       			"actor":    actor,

     

       199
       210
        
       			"issue_id": issue.IssueId,

     

       200
       211
        
       		},

     

       201
       212
        
       	})

     
···

       204
       215
        
       	}

     

       205
       216
        
       }

     

       206
       217
        
       

     

       207
       207
       -
       func (n *posthogNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       218
       218
       +
       func (n *posthogNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {

     

       219
       219
       +
       	var event string

     

       220
       220
       +
       	switch pull.State {

     

       221
       221
       +
       	case models.PullClosed:

     

       222
       222
       +
       		event = "pull_closed"

     

       223
       223
       +
       	case models.PullOpen:

     

       224
       224
       +
       		event = "pull_reopen"

     

       225
       225
       +
       	case models.PullMerged:

     

       226
       226
       +
       		event = "pull_merged"

     

       227
       227
       +
       	default:

     

       228
       228
       +
       		log.Println("posthog: unexpected new PR state:", pull.State)

     

       229
       229
       +
       		return

     

       230
       230
       +
       	}

     

       208
       231
        
       	err := n.client.Enqueue(posthog.Capture{

     

       209
       232
        
       		DistinctId: pull.OwnerDid,

     

       210
       210
       -
       		Event:      "pull_merged",

     

       233
       233
       +
       		Event:      event,

     

       211
       234
        
       		Properties: posthog.Properties{

     

       212
       235
        
       			"repo_at": pull.RepoAt,

     

       213
       236
        
       			"pull_id": pull.PullId,

     

       237
       237
       +
       			"actor":   actor,

     

       214
       238
        
       		},

     

       215
       239
        
       	})

     

       216
       240
        
       	if err != nil {

+21 -17

appview/oauth/handler.go

···

       4
       4
        
       	"bytes"

     

       5
       5
        
       	"context"

     

       6
       6
        
       	"encoding/json"

     

       7
       7
       +
       	"errors"

     

       7
       8
        
       	"fmt"

     

       8
       9
        
       	"net/http"

     

       9
       10
        
       	"slices"

     

       10
       11
        
       	"time"

     

       11
       12
        
       

     

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

     

       12
       14
        
       	"github.com/go-chi/chi/v5"

     

       13
       13
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       14
       15
        
       	"github.com/posthog/posthog-go"

     

       15
       16
        
       	"tangled.org/core/api/tangled"

     

       16
       17
        
       	"tangled.org/core/appview/db"

     

       17
       18
        
       	"tangled.org/core/consts"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       18
       20
        
       	"tangled.org/core/tid"

     

       19
       21
        
       )

     

       20
       22
        
       

     
···

       30
       32
        
       func (o *OAuth) clientMetadata(w http.ResponseWriter, r *http.Request) {

     

       31
       33
        
       	doc := o.ClientApp.Config.ClientMetadata()

     

       32
       34
        
       	doc.JWKSURI = &o.JwksUri

     

       35
       35
       +
       	doc.ClientName = &o.ClientName

     

       36
       36
       +
       	doc.ClientURI = &o.ClientUri

     

       33
       37
        
       

     

       34
       38
        
       	w.Header().Set("Content-Type", "application/json")

     

       35
       39
        
       	if err := json.NewEncoder(w).Encode(doc); err != nil {

     
···

       39
       43
        
       }

     

       40
       44
        
       

     

       41
       45
        
       func (o *OAuth) jwks(w http.ResponseWriter, r *http.Request) {

     

       42
       42
       -
       	jwks := o.Config.OAuth.Jwks

     

       43
       43
       -
       	pubKey, err := pubKeyFromJwk(jwks)

     

       44
       44
       -
       	if err != nil {

     

       45
       45
       -
       		o.Logger.Error("error parsing public key", "err", err)

     

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

     

       47
       47
       +
       	body := o.ClientApp.Config.PublicJWKS()

     

       48
       48
       +
       	if err := json.NewEncoder(w).Encode(body); err != nil {

     

       46
       49
        
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       47
       50
        
       		return

     

       48
       51
        
       	}

     

       49
       49
       -
       

     

       50
       50
       -
       	response := map[string]any{

     

       51
       51
       -
       		"keys": []jwk.Key{pubKey},

     

       52
       52
       -
       	}

     

       53
       53
       -
       

     

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

     

       55
       55
       -
       	w.WriteHeader(http.StatusOK)

     

       56
       56
       -
       	json.NewEncoder(w).Encode(response)

     

       57
       52
        
       }

     

       58
       53
        
       

     

       59
       54
        
       func (o *OAuth) callback(w http.ResponseWriter, r *http.Request) {

     

       60
       55
        
       	ctx := r.Context()

     

       56
       56
       +
       	l := o.Logger.With("query", r.URL.Query())

     

       61
       57
        
       

     

       62
       58
        
       	sessData, err := o.ClientApp.ProcessCallback(ctx, r.URL.Query())

     

       63
       59
        
       	if err != nil {

     

       64
       64
       -
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       60
       60
       +
       		var callbackErr *oauth.AuthRequestCallbackError

     

       61
       61
       +
       		if errors.As(err, &callbackErr) {

     

       62
       62
       +
       			l.Debug("callback error", "err", callbackErr)

     

       63
       63
       +
       			http.Redirect(w, r, fmt.Sprintf("/login?error=%s", callbackErr.ErrorCode), http.StatusFound)

     

       64
       64
       +
       			return

     

       65
       65
       +
       		}

     

       66
       66
       +
       		l.Error("failed to process callback", "err", err)

     

       67
       67
       +
       		http.Redirect(w, r, "/login?error=oauth", http.StatusFound)

     

       65
       68
        
       		return

     

       66
       69
        
       	}

     

       67
       70
        
       

     

       68
       71
        
       	if err := o.SaveSession(w, r, sessData); err != nil {

     

       69
       69
       -
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       72
       72
       +
       		l.Error("failed to save session", "data", sessData, "err", err)

     

       73
       73
       +
       		http.Redirect(w, r, "/login?error=session", http.StatusFound)

     

       70
       74
        
       		return

     

       71
       75
        
       	}

     

       72
       76
        
       

     
···

       94
       98
        
       	// and create an sh.tangled.spindle.member record with that

     

       95
       99
        
       	spindleMembers, err := db.GetSpindleMembers(

     

       96
       100
        
       		o.Db,

     

       97
       97
       -
       		db.FilterEq("instance", "spindle.tangled.sh"),

     

       98
       98
       -
       		db.FilterEq("subject", did),

     

       101
       101
       +
       		orm.FilterEq("instance", "spindle.tangled.sh"),

     

       102
       102
       +
       		orm.FilterEq("subject", did),

     

       99
       103
        
       	)

     

       100
       104
        
       	if err != nil {

     

       101
       105
        
       		l.Error("failed to get spindle members", "err", err)

+50 -24

appview/oauth/oauth.go

···

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

     

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

     

       12
       12
        
       	atpclient "github.com/bluesky-social/indigo/atproto/client"

     

       13
       13
       +
       	atcrypto "github.com/bluesky-social/indigo/atproto/crypto"

     

       13
       14
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       14
       15
        
       	xrpc "github.com/bluesky-social/indigo/xrpc"

     

       15
       16
        
       	"github.com/gorilla/sessions"

     

       16
       16
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       17
       17
        
       	"github.com/posthog/posthog-go"

     

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

     

       19
       19
        
       	"tangled.org/core/appview/db"

     
···

       26
       26
        
       	SessStore  *sessions.CookieStore

     

       27
       27
        
       	Config     *config.Config

     

       28
       28
        
       	JwksUri    string

     

       29
       29
       +
       	ClientName string

     

       30
       30
       +
       	ClientUri  string

     

       29
       31
        
       	Posthog    posthog.Client

     

       30
       32
        
       	Db         *db.DB

     

       31
       33
        
       	Enforcer   *rbac.Enforcer

     
···

       34
       36
        
       }

     

       35
       37
        
       

     

       36
       38
        
       func New(config *config.Config, ph posthog.Client, db *db.DB, enforcer *rbac.Enforcer, res *idresolver.Resolver, logger *slog.Logger) (*OAuth, error) {

     

       37
       37
       -
       

     

       38
       39
        
       	var oauthConfig oauth.ClientConfig

     

       39
       40
        
       	var clientUri string

     

       40
       40
       -
       

     

       41
       41
        
       	if config.Core.Dev {

     

       42
       42
        
       		clientUri = "http://127.0.0.1:3000"

     

       43
       43
        
       		callbackUri := clientUri + "/oauth/callback"

     
···

       49
       49
        
       		oauthConfig = oauth.NewPublicConfig(clientId, callbackUri, []string{"atproto", "transition:generic"})

     

       50
       50
        
       	}

     

       51
       51
        
       

     

       52
       52
       +
       	// configure client secret

     

       53
       53
       +
       	priv, err := atcrypto.ParsePrivateMultibase(config.OAuth.ClientSecret)

     

       54
       54
       +
       	if err != nil {

     

       55
       55
       +
       		return nil, err

     

       56
       56
       +
       	}

     

       57
       57
       +
       	if err := oauthConfig.SetClientSecret(priv, config.OAuth.ClientKid); err != nil {

     

       58
       58
       +
       		return nil, err

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       52
       61
        
       	jwksUri := clientUri + "/oauth/jwks.json"

     

       53
       62
        
       

     

       54
       54
       -
       	authStore, err := NewRedisStore(config.Redis.ToURL())

     

       63
       63
       +
       	authStore, err := NewRedisStore(&RedisStoreConfig{

     

       64
       64
       +
       		RedisURL:                  config.Redis.ToURL(),

     

       65
       65
       +
       		SessionExpiryDuration:     time.Hour * 24 * 90,

     

       66
       66
       +
       		SessionInactivityDuration: time.Hour * 24 * 14,

     

       67
       67
       +
       		AuthRequestExpiryDuration: time.Minute * 30,

     

       68
       68
       +
       	})

     

       55
       69
        
       	if err != nil {

     

       56
       70
        
       		return nil, err

     

       57
       71
        
       	}

     

       58
       72
        
       

     

       59
       73
        
       	sessStore := sessions.NewCookieStore([]byte(config.Core.CookieSecret))

     

       60
       74
        
       

     

       75
       75
       +
       	clientApp := oauth.NewClientApp(&oauthConfig, authStore)

     

       76
       76
       +
       	clientApp.Dir = res.Directory()

     

       77
       77
       +
       	// allow non-public transports in dev mode

     

       78
       78
       +
       	if config.Core.Dev {

     

       79
       79
       +
       		clientApp.Resolver.Client.Transport = http.DefaultTransport

     

       80
       80
       +
       	}

     

       81
       81
       +
       

     

       82
       82
       +
       	clientName := config.Core.AppviewName

     

       83
       83
       +
       

     

       84
       84
       +
       	logger.Info("oauth setup successfully", "IsConfidential", clientApp.Config.IsConfidential())

     

       61
       85
        
       	return &OAuth{

     

       62
       62
       -
       		ClientApp:  oauth.NewClientApp(&oauthConfig, authStore),

     

       86
       86
       +
       		ClientApp:  clientApp,

     

       63
       87
        
       		Config:     config,

     

       64
       88
        
       		SessStore:  sessStore,

     

       65
       89
        
       		JwksUri:    jwksUri,

     

       90
       90
       +
       		ClientName: clientName,

     

       91
       91
       +
       		ClientUri:  clientUri,

     

       66
       92
        
       		Posthog:    ph,

     

       67
       93
        
       		Db:         db,

     

       68
       94
        
       		Enforcer:   enforcer,

     
···

       137
       163
        
       	return errors.Join(err1, err2)

     

       138
       164
        
       }

     

       139
       165
        
       

     

       140
       140
       -
       func pubKeyFromJwk(jwks string) (jwk.Key, error) {

     

       141
       141
       -
       	k, err := jwk.ParseKey([]byte(jwks))

     

       142
       142
       -
       	if err != nil {

     

       143
       143
       -
       		return nil, err

     

       144
       144
       -
       	}

     

       145
       145
       -
       	pubKey, err := k.PublicKey()

     

       146
       146
       -
       	if err != nil {

     

       147
       147
       -
       		return nil, err

     

       148
       148
       -
       	}

     

       149
       149
       -
       	return pubKey, nil

     

       150
       150
       -
       }

     

       151
       151
       -
       

     

       152
       166
        
       type User struct {

     

       153
       167
        
       	Did string

     

       154
       168
        
       	Pds string

     

       155
       169
        
       }

     

       156
       170
        
       

     

       157
       171
        
       func (o *OAuth) GetUser(r *http.Request) *User {

     

       158
       158
       -
       	sess, err := o.SessStore.Get(r, SessionName)

     

       159
       159
       -
       

     

       160
       160
       -
       	if err != nil || sess.IsNew {

     

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

     

       173
       173
       +
       	if err != nil {

     

       161
       174
        
       		return nil

     

       162
       175
        
       	}

     

       163
       176
        
       

     

       164
       177
        
       	return &User{

     

       165
       165
       -
       		Did: sess.Values[SessionDid].(string),

     

       166
       166
       -
       		Pds: sess.Values[SessionPds].(string),

     

       178
       178
       +
       		Did: sess.Data.AccountDID.String(),

     

       179
       179
       +
       		Pds: sess.Data.HostURL,

     

       167
       180
        
       	}

     

       168
       181
        
       }

     

       169
       182
        
       

     
···

       189
       202
        
       	exp     int64

     

       190
       203
        
       	lxm     string

     

       191
       204
        
       	dev     bool

     

       205
       205
       +
       	timeout time.Duration

     

       192
       206
        
       }

     

       193
       207
        
       

     

       194
       208
        
       type ServiceClientOpt func(*ServiceClientOpts)

     

       195
       209
        
       

     

       210
       210
       +
       func DefaultServiceClientOpts() ServiceClientOpts {

     

       211
       211
       +
       	return ServiceClientOpts{

     

       212
       212
       +
       		timeout: time.Second * 5,

     

       213
       213
       +
       	}

     

       214
       214
       +
       }

     

       215
       215
       +
       

     

       196
       216
        
       func WithService(service string) ServiceClientOpt {

     

       197
       217
        
       	return func(s *ServiceClientOpts) {

     

       198
       218
        
       		s.service = service

     
···

       220
       240
        
       	}

     

       221
       241
        
       }

     

       222
       242
        
       

     

       243
       243
       +
       func WithTimeout(timeout time.Duration) ServiceClientOpt {

     

       244
       244
       +
       	return func(s *ServiceClientOpts) {

     

       245
       245
       +
       		s.timeout = timeout

     

       246
       246
       +
       	}

     

       247
       247
       +
       }

     

       248
       248
       +
       

     

       223
       249
        
       func (s *ServiceClientOpts) Audience() string {

     

       224
       250
        
       	return fmt.Sprintf("did:web:%s", s.service)

     

       225
       251
        
       }

     
···

       234
       260
        
       }

     

       235
       261
        
       

     

       236
       262
        
       func (o *OAuth) ServiceClient(r *http.Request, os ...ServiceClientOpt) (*xrpc.Client, error) {

     

       237
       237
       -
       	opts := ServiceClientOpts{}

     

       263
       263
       +
       	opts := DefaultServiceClientOpts()

     

       238
       264
        
       	for _, o := range os {

     

       239
       265
        
       		o(&opts)

     

       240
       266
        
       	}

     
···

       261
       287
        
       		},

     

       262
       288
        
       		Host: opts.Host(),

     

       263
       289
        
       		Client: &http.Client{

     

       264
       264
       -
       			Timeout: time.Second * 5,

     

       290
       290
       +
       			Timeout: opts.timeout,

     

       265
       291
        
       		},

     

       266
       292
        
       	}, nil

     

       267
       293
        
       }

+110 -11

appview/oauth/store.go

···

       11
       11
        
       	"github.com/redis/go-redis/v9"

     

       12
       12
        
       )

     

       13
       13
        
       

     

       14
       14
       +
       type RedisStoreConfig struct {

     

       15
       15
       +
       	RedisURL string

     

       16
       16
       +
       

     

       17
       17
       +
       	// The purpose of these limits is to avoid dead sessions hanging around in the db indefinitely.

     

       18
       18
       +
       	// The durations here should be *at least as long as* the expected duration of the oauth session itself.

     

       19
       19
       +
       	SessionExpiryDuration     time.Duration // duration since session creation (max TTL)

     

       20
       20
       +
       	SessionInactivityDuration time.Duration // duration since last session update

     

       21
       21
       +
       	AuthRequestExpiryDuration time.Duration // duration since auth request creation

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       14
       24
        
       // redis-backed implementation of ClientAuthStore.

     

       15
       25
        
       type RedisStore struct {

     

       16
       16
       -
       	client         *redis.Client

     

       17
       17
       -
       	SessionTTL     time.Duration

     

       18
       18
       -
       	AuthRequestTTL time.Duration

     

       26
       26
       +
       	client *redis.Client

     

       27
       27
       +
       	cfg    *RedisStoreConfig

     

       19
       28
        
       }

     

       20
       29
        
       

     

       21
       30
        
       var _ oauth.ClientAuthStore = &RedisStore{}

     

       22
       31
        
       

     

       23
       23
       -
       func NewRedisStore(redisURL string) (*RedisStore, error) {

     

       24
       24
       -
       	opts, err := redis.ParseURL(redisURL)

     

       32
       32
       +
       type sessionMetadata struct {

     

       33
       33
       +
       	CreatedAt time.Time `json:"created_at"`

     

       34
       34
       +
       	UpdatedAt time.Time `json:"updated_at"`

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       func NewRedisStore(cfg *RedisStoreConfig) (*RedisStore, error) {

     

       38
       38
       +
       	if cfg == nil {

     

       39
       39
       +
       		return nil, fmt.Errorf("missing cfg")

     

       40
       40
       +
       	}

     

       41
       41
       +
       	if cfg.RedisURL == "" {

     

       42
       42
       +
       		return nil, fmt.Errorf("missing RedisURL")

     

       43
       43
       +
       	}

     

       44
       44
       +
       	if cfg.SessionExpiryDuration == 0 {

     

       45
       45
       +
       		return nil, fmt.Errorf("missing SessionExpiryDuration")

     

       46
       46
       +
       	}

     

       47
       47
       +
       	if cfg.SessionInactivityDuration == 0 {

     

       48
       48
       +
       		return nil, fmt.Errorf("missing SessionInactivityDuration")

     

       49
       49
       +
       	}

     

       50
       50
       +
       	if cfg.AuthRequestExpiryDuration == 0 {

     

       51
       51
       +
       		return nil, fmt.Errorf("missing AuthRequestExpiryDuration")

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	opts, err := redis.ParseURL(cfg.RedisURL)

     

       25
       55
        
       	if err != nil {

     

       26
       56
        
       		return nil, fmt.Errorf("failed to parse redis URL: %w", err)

     

       27
       57
        
       	}

     
···

       37
       67
        
       	}

     

       38
       68
        
       

     

       39
       69
        
       	return &RedisStore{

     

       40
       40
       -
       		client:         client,

     

       41
       41
       -
       		SessionTTL:     30 * 24 * time.Hour, // 30 days

     

       42
       42
       -
       		AuthRequestTTL: 10 * time.Minute,    // 10 minutes

     

       70
       70
       +
       		client: client,

     

       71
       71
       +
       		cfg:    cfg,

     

       43
       72
        
       	}, nil

     

       44
       73
        
       }

     

       45
       74
        
       

     
···

       51
       80
        
       	return fmt.Sprintf("oauth:session:%s:%s", did, sessionID)

     

       52
       81
        
       }

     

       53
       82
        
       

     

       83
       83
       +
       func sessionMetadataKey(did syntax.DID, sessionID string) string {

     

       84
       84
       +
       	return fmt.Sprintf("oauth:session_meta:%s:%s", did, sessionID)

     

       85
       85
       +
       }

     

       86
       86
       +
       

     

       54
       87
        
       func authRequestKey(state string) string {

     

       55
       88
        
       	return fmt.Sprintf("oauth:auth_request:%s", state)

     

       56
       89
        
       }

     

       57
       90
        
       

     

       58
       91
        
       func (r *RedisStore) GetSession(ctx context.Context, did syntax.DID, sessionID string) (*oauth.ClientSessionData, error) {

     

       59
       92
        
       	key := sessionKey(did, sessionID)

     

       93
       93
       +
       	metaKey := sessionMetadataKey(did, sessionID)

     

       94
       94
       +
       

     

       95
       95
       +
       	// Check metadata for inactivity expiry

     

       96
       96
       +
       	metaData, err := r.client.Get(ctx, metaKey).Bytes()

     

       97
       97
       +
       	if err == redis.Nil {

     

       98
       98
       +
       		return nil, fmt.Errorf("session not found: %s", did)

     

       99
       99
       +
       	}

     

       100
       100
       +
       	if err != nil {

     

       101
       101
       +
       		return nil, fmt.Errorf("failed to get session metadata: %w", err)

     

       102
       102
       +
       	}

     

       103
       103
       +
       

     

       104
       104
       +
       	var meta sessionMetadata

     

       105
       105
       +
       	if err := json.Unmarshal(metaData, &meta); err != nil {

     

       106
       106
       +
       		return nil, fmt.Errorf("failed to unmarshal session metadata: %w", err)

     

       107
       107
       +
       	}

     

       108
       108
       +
       

     

       109
       109
       +
       	// Check if session has been inactive for too long

     

       110
       110
       +
       	inactiveThreshold := time.Now().Add(-r.cfg.SessionInactivityDuration)

     

       111
       111
       +
       	if meta.UpdatedAt.Before(inactiveThreshold) {

     

       112
       112
       +
       		// Session is inactive, delete it

     

       113
       113
       +
       		r.client.Del(ctx, key, metaKey)

     

       114
       114
       +
       		return nil, fmt.Errorf("session expired due to inactivity: %s", did)

     

       115
       115
       +
       	}

     

       116
       116
       +
       

     

       117
       117
       +
       	// Get the actual session data

     

       60
       118
        
       	data, err := r.client.Get(ctx, key).Bytes()

     

       61
       119
        
       	if err == redis.Nil {

     

       62
       120
        
       		return nil, fmt.Errorf("session not found: %s", did)

     
···

       75
       133
        
       

     

       76
       134
        
       func (r *RedisStore) SaveSession(ctx context.Context, sess oauth.ClientSessionData) error {

     

       77
       135
        
       	key := sessionKey(sess.AccountDID, sess.SessionID)

     

       136
       136
       +
       	metaKey := sessionMetadataKey(sess.AccountDID, sess.SessionID)

     

       78
       137
        
       

     

       79
       138
        
       	data, err := json.Marshal(sess)

     

       80
       139
        
       	if err != nil {

     

       81
       140
        
       		return fmt.Errorf("failed to marshal session: %w", err)

     

       82
       141
        
       	}

     

       83
       142
        
       

     

       84
       84
       -
       	if err := r.client.Set(ctx, key, data, r.SessionTTL).Err(); err != nil {

     

       143
       143
       +
       	// Check if session already exists to preserve CreatedAt

     

       144
       144
       +
       	var meta sessionMetadata

     

       145
       145
       +
       	existingMetaData, err := r.client.Get(ctx, metaKey).Bytes()

     

       146
       146
       +
       	if err == redis.Nil {

     

       147
       147
       +
       		// New session

     

       148
       148
       +
       		meta = sessionMetadata{

     

       149
       149
       +
       			CreatedAt: time.Now(),

     

       150
       150
       +
       			UpdatedAt: time.Now(),

     

       151
       151
       +
       		}

     

       152
       152
       +
       	} else if err != nil {

     

       153
       153
       +
       		return fmt.Errorf("failed to check existing session metadata: %w", err)

     

       154
       154
       +
       	} else {

     

       155
       155
       +
       		// Existing session - preserve CreatedAt, update UpdatedAt

     

       156
       156
       +
       		if err := json.Unmarshal(existingMetaData, &meta); err != nil {

     

       157
       157
       +
       			return fmt.Errorf("failed to unmarshal existing session metadata: %w", err)

     

       158
       158
       +
       		}

     

       159
       159
       +
       		meta.UpdatedAt = time.Now()

     

       160
       160
       +
       	}

     

       161
       161
       +
       

     

       162
       162
       +
       	// Calculate remaining TTL based on creation time

     

       163
       163
       +
       	remainingTTL := r.cfg.SessionExpiryDuration - time.Since(meta.CreatedAt)

     

       164
       164
       +
       	if remainingTTL <= 0 {

     

       165
       165
       +
       		return fmt.Errorf("session has expired")

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	// Use the shorter of: remaining TTL or inactivity duration

     

       169
       169
       +
       	ttl := min(r.cfg.SessionInactivityDuration, remainingTTL)

     

       170
       170
       +
       

     

       171
       171
       +
       	// Save session data

     

       172
       172
       +
       	if err := r.client.Set(ctx, key, data, ttl).Err(); err != nil {

     

       85
       173
        
       		return fmt.Errorf("failed to save session: %w", err)

     

       86
       174
        
       	}

     

       87
       175
        
       

     

       176
       176
       +
       	// Save metadata

     

       177
       177
       +
       	metaData, err := json.Marshal(meta)

     

       178
       178
       +
       	if err != nil {

     

       179
       179
       +
       		return fmt.Errorf("failed to marshal session metadata: %w", err)

     

       180
       180
       +
       	}

     

       181
       181
       +
       	if err := r.client.Set(ctx, metaKey, metaData, ttl).Err(); err != nil {

     

       182
       182
       +
       		return fmt.Errorf("failed to save session metadata: %w", err)

     

       183
       183
       +
       	}

     

       184
       184
       +
       

     

       88
       185
        
       	return nil

     

       89
       186
        
       }

     

       90
       187
        
       

     

       91
       188
        
       func (r *RedisStore) DeleteSession(ctx context.Context, did syntax.DID, sessionID string) error {

     

       92
       189
        
       	key := sessionKey(did, sessionID)

     

       93
       93
       -
       	if err := r.client.Del(ctx, key).Err(); err != nil {

     

       190
       190
       +
       	metaKey := sessionMetadataKey(did, sessionID)

     

       191
       191
       +
       

     

       192
       192
       +
       	if err := r.client.Del(ctx, key, metaKey).Err(); err != nil {

     

       94
       193
        
       		return fmt.Errorf("failed to delete session: %w", err)

     

       95
       194
        
       	}

     

       96
       195
        
       	return nil

     
···

       131
       230
        
       		return fmt.Errorf("failed to marshal auth request: %w", err)

     

       132
       231
        
       	}

     

       133
       232
        
       

     

       134
       134
       -
       	if err := r.client.Set(ctx, key, data, r.AuthRequestTTL).Err(); err != nil {

     

       233
       233
       +
       	if err := r.client.Set(ctx, key, data, r.cfg.AuthRequestExpiryDuration).Err(); err != nil {

     

       135
       234
        
       		return fmt.Errorf("failed to save auth request: %w", err)

     

       136
       235
        
       	}

     

       137
       236

+59 -10

appview/ogcard/card.go

···

       7
       7
        
       import (

     

       8
       8
        
       	"bytes"

     

       9
       9
        
       	"fmt"

     

       10
       10
       +
       	"html/template"

     

       10
       11
        
       	"image"

     

       11
       12
        
       	"image/color"

     

       12
       13
        
       	"io"

     
···

       279
       280
        
       	return width, nil

     

       280
       281
        
       }

     

       281
       282
        
       

     

       282
       282
       -
       // DrawSVGIcon draws an SVG icon from the embedded files at the specified position

     

       283
       283
       -
       func (c *Card) DrawSVGIcon(svgPath string, x, y, size int, iconColor color.Color) error {

     

       284
       284
       -
       	svgData, err := pages.Files.ReadFile(svgPath)

     

       285
       285
       -
       	if err != nil {

     

       286
       286
       -
       		return fmt.Errorf("failed to read SVG file %s: %w", svgPath, err)

     

       287
       287
       -
       	}

     

       288
       288
       -
       

     

       283
       283
       +
       func BuildSVGIconFromData(svgData []byte, iconColor color.Color) (*oksvg.SvgIcon, error) {

     

       289
       284
        
       	// Convert color to hex string for SVG

     

       290
       285
        
       	rgba, isRGBA := iconColor.(color.RGBA)

     

       291
       286
        
       	if !isRGBA {

     
···

       304
       299
        
       	// Parse SVG

     

       305
       300
        
       	icon, err := oksvg.ReadIconStream(strings.NewReader(svgString))

     

       306
       301
        
       	if err != nil {

     

       307
       307
       -
       		return fmt.Errorf("failed to parse SVG %s: %w", svgPath, err)

     

       302
       302
       +
       		return nil, fmt.Errorf("failed to parse SVG: %w", err)

     

       308
       303
        
       	}

     

       309
       304
        
       

     

       305
       305
       +
       	return icon, nil

     

       306
       306
       +
       }

     

       307
       307
       +
       

     

       308
       308
       +
       func BuildSVGIconFromPath(svgPath string, iconColor color.Color) (*oksvg.SvgIcon, error) {

     

       309
       309
       +
       	svgData, err := pages.Files.ReadFile(svgPath)

     

       310
       310
       +
       	if err != nil {

     

       311
       311
       +
       		return nil, fmt.Errorf("failed to read SVG file %s: %w", svgPath, err)

     

       312
       312
       +
       	}

     

       313
       313
       +
       

     

       314
       314
       +
       	icon, err := BuildSVGIconFromData(svgData, iconColor)

     

       315
       315
       +
       	if err != nil {

     

       316
       316
       +
       		return nil, fmt.Errorf("failed to build SVG icon %s: %w", svgPath, err)

     

       317
       317
       +
       	}

     

       318
       318
       +
       

     

       319
       319
       +
       	return icon, nil

     

       320
       320
       +
       }

     

       321
       321
       +
       

     

       322
       322
       +
       func BuildLucideIcon(name string, iconColor color.Color) (*oksvg.SvgIcon, error) {

     

       323
       323
       +
       	return BuildSVGIconFromPath(fmt.Sprintf("static/icons/%s.svg", name), iconColor)

     

       324
       324
       +
       }

     

       325
       325
       +
       

     

       326
       326
       +
       func (c *Card) DrawLucideIcon(name string, x, y, size int, iconColor color.Color) error {

     

       327
       327
       +
       	icon, err := BuildSVGIconFromPath(fmt.Sprintf("static/icons/%s.svg", name), iconColor)

     

       328
       328
       +
       	if err != nil {

     

       329
       329
       +
       		return err

     

       330
       330
       +
       	}

     

       331
       331
       +
       

     

       332
       332
       +
       	c.DrawSVGIcon(icon, x, y, size)

     

       333
       333
       +
       

     

       334
       334
       +
       	return nil

     

       335
       335
       +
       }

     

       336
       336
       +
       

     

       337
       337
       +
       func (c *Card) DrawDollySilhouette(x, y, size int, iconColor color.Color) error {

     

       338
       338
       +
       	tpl, err := template.New("dolly").

     

       339
       339
       +
       		ParseFS(pages.Files, "templates/fragments/dolly/silhouette.html")

     

       340
       340
       +
       	if err != nil {

     

       341
       341
       +
       		return fmt.Errorf("failed to read dolly silhouette template: %w", err)

     

       342
       342
       +
       	}

     

       343
       343
       +
       

     

       344
       344
       +
       	var svgData bytes.Buffer

     

       345
       345
       +
       	if err = tpl.ExecuteTemplate(&svgData, "fragments/dolly/silhouette", nil); err != nil {

     

       346
       346
       +
       		return fmt.Errorf("failed to execute dolly silhouette template: %w", err)

     

       347
       347
       +
       	}

     

       348
       348
       +
       

     

       349
       349
       +
       	icon, err := BuildSVGIconFromData(svgData.Bytes(), iconColor)

     

       350
       350
       +
       	if err != nil {

     

       351
       351
       +
       		return err

     

       352
       352
       +
       	}

     

       353
       353
       +
       

     

       354
       354
       +
       	c.DrawSVGIcon(icon, x, y, size)

     

       355
       355
       +
       

     

       356
       356
       +
       	return nil

     

       357
       357
       +
       }

     

       358
       358
       +
       

     

       359
       359
       +
       // DrawSVGIcon draws an SVG icon from the embedded files at the specified position

     

       360
       360
       +
       func (c *Card) DrawSVGIcon(icon *oksvg.SvgIcon, x, y, size int) {

     

       310
       361
        
       	// Set the icon size

     

       311
       362
        
       	w, h := float64(size), float64(size)

     

       312
       363
        
       	icon.SetTarget(0, 0, w, h)

     
···

       334
       385
        
       	}

     

       335
       386
        
       

     

       336
       387
        
       	draw.Draw(c.Img, destRect, iconImg, image.Point{}, draw.Over)

     

       337
       337
       -
       

     

       338
       338
       -
       	return nil

     

       339
       388
        
       }

     

       340
       389
        
       

     

       341
       390
        
       // DrawImage fills the card with an image, scaled to maintain the original aspect ratio and centered with respect to the non-filled dimension

+102 -13

appview/pages/funcmap.go

···

       1
       1
        
       package pages

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"context"

     

       5
       6
        
       	"crypto/hmac"

     

       6
       7
        
       	"crypto/sha256"

     
···

       17
       18
        
       	"strings"

     

       18
       19
        
       	"time"

     

       19
       20
        
       

     

       21
       21
       +
       	"github.com/alecthomas/chroma/v2"

     

       22
       22
       +
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       23
       23
       +
       	"github.com/alecthomas/chroma/v2/lexers"

     

       24
       24
       +
       	"github.com/alecthomas/chroma/v2/styles"

     

       20
       25
        
       	"github.com/dustin/go-humanize"

     

       21
       26
        
       	"github.com/go-enry/go-enry/v2"

     

       27
       27
       +
       	"github.com/yuin/goldmark"

     

       22
       28
        
       	"tangled.org/core/appview/filetree"

     

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

     

       23
       30
        
       	"tangled.org/core/appview/pages/markup"

     

       24
       31
        
       	"tangled.org/core/crypto"

     

       25
       32
        
       )

     
···

       38
       45
        
       		"contains": func(s string, target string) bool {

     

       39
       46
        
       			return strings.Contains(s, target)

     

       40
       47
        
       		},

     

       48
       48
       +
       		"stripPort": func(hostname string) string {

     

       49
       49
       +
       			if strings.Contains(hostname, ":") {

     

       50
       50
       +
       				return strings.Split(hostname, ":")[0]

     

       51
       51
       +
       			}

     

       52
       52
       +
       			return hostname

     

       53
       53
       +
       		},

     

       41
       54
        
       		"mapContains": func(m any, key any) bool {

     

       42
       55
        
       			mapValue := reflect.ValueOf(m)

     

       43
       56
        
       			if mapValue.Kind() != reflect.Map {

     
···

       57
       70
        
       				return "handle.invalid"

     

       58
       71
        
       			}

     

       59
       72
        
       

     

       60
       60
       -
       			return "@" + identity.Handle.String()

     

       73
       73
       +
       			return identity.Handle.String()

     

       74
       74
       +
       		},

     

       75
       75
       +
       		"ownerSlashRepo": func(repo *models.Repo) string {

     

       76
       76
       +
       			ownerId, err := p.resolver.ResolveIdent(context.Background(), repo.Did)

     

       77
       77
       +
       			if err != nil {

     

       78
       78
       +
       				return repo.DidSlashRepo()

     

       79
       79
       +
       			}

     

       80
       80
       +
       			handle := ownerId.Handle

     

       81
       81
       +
       			if handle != "" && !handle.IsInvalidHandle() {

     

       82
       82
       +
       				return string(handle) + "/" + repo.Name

     

       83
       83
       +
       			}

     

       84
       84
       +
       			return repo.DidSlashRepo()

     

       61
       85
        
       		},

     

       62
       86
        
       		"truncateAt30": func(s string) string {

     

       63
       87
        
       			if len(s) <= 30 {

     
···

       67
       91
        
       		},

     

       68
       92
        
       		"splitOn": func(s, sep string) []string {

     

       69
       93
        
       			return strings.Split(s, sep)

     

       94
       94
       +
       		},

     

       95
       95
       +
       		"string": func(v any) string {

     

       96
       96
       +
       			return fmt.Sprint(v)

     

       70
       97
        
       		},

     

       71
       98
        
       		"int64": func(a int) int64 {

     

       72
       99
        
       			return int64(a)

     
···

       84
       111
        
       		"sub": func(a, b int) int {

     

       85
       112
        
       			return a - b

     

       86
       113
        
       		},

     

       114
       114
       +
       		"mul": func(a, b int) int {

     

       115
       115
       +
       			return a * b

     

       116
       116
       +
       		},

     

       117
       117
       +
       		"div": func(a, b int) int {

     

       118
       118
       +
       			return a / b

     

       119
       119
       +
       		},

     

       120
       120
       +
       		"mod": func(a, b int) int {

     

       121
       121
       +
       			return a % b

     

       122
       122
       +
       		},

     

       87
       123
        
       		"f64": func(a int) float64 {

     

       88
       124
        
       			return float64(a)

     

       89
       125
        
       		},

     
···

       116
       152
        
       

     

       117
       153
        
       			return b

     

       118
       154
        
       		},

     

       119
       119
       -
       		"didOrHandle": func(did, handle string) string {

     

       120
       120
       -
       			if handle != "" {

     

       121
       121
       -
       				return fmt.Sprintf("@%s", handle)

     

       122
       122
       -
       			} else {

     

       123
       123
       -
       				return did

     

       124
       124
       -
       			}

     

       125
       125
       -
       		},

     

       126
       155
        
       		"assoc": func(values ...string) ([][]string, error) {

     

       127
       156
        
       			if len(values)%2 != 0 {

     

       128
       157
        
       				return nil, fmt.Errorf("invalid assoc call, must have an even number of arguments")

     
···

       133
       162
        
       			}

     

       134
       163
        
       			return pairs, nil

     

       135
       164
        
       		},

     

       136
       136
       -
       		"append": func(s []string, values ...string) []string {

     

       165
       165
       +
       		"append": func(s []any, values ...any) []any {

     

       137
       166
        
       			s = append(s, values...)

     

       138
       167
        
       			return s

     

       139
       168
        
       		},

     
···

       232
       261
        
       		},

     

       233
       262
        
       		"description": func(text string) template.HTML {

     

       234
       263
        
       			p.rctx.RendererType = markup.RendererTypeDefault

     

       264
       264
       +
       			htmlString := p.rctx.RenderMarkdownWith(text, goldmark.New())

     

       265
       265
       +
       			sanitized := p.rctx.SanitizeDescription(htmlString)

     

       266
       266
       +
       			return template.HTML(sanitized)

     

       267
       267
       +
       		},

     

       268
       268
       +
       		"readme": func(text string) template.HTML {

     

       269
       269
       +
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       235
       270
        
       			htmlString := p.rctx.RenderMarkdown(text)

     

       236
       236
       -
       			sanitized := p.rctx.SanitizeDescription(htmlString)

     

       271
       271
       +
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       237
       272
        
       			return template.HTML(sanitized)

     

       238
       273
        
       		},

     

       274
       274
       +
       		"code": func(content, path string) string {

     

       275
       275
       +
       			var style *chroma.Style = styles.Get("catpuccin-latte")

     

       276
       276
       +
       			formatter := chromahtml.New(

     

       277
       277
       +
       				chromahtml.InlineCode(false),

     

       278
       278
       +
       				chromahtml.WithLineNumbers(true),

     

       279
       279
       +
       				chromahtml.WithLinkableLineNumbers(true, "L"),

     

       280
       280
       +
       				chromahtml.Standalone(false),

     

       281
       281
       +
       				chromahtml.WithClasses(true),

     

       282
       282
       +
       			)

     

       283
       283
       +
       

     

       284
       284
       +
       			lexer := lexers.Get(filepath.Base(path))

     

       285
       285
       +
       			if lexer == nil {

     

       286
       286
       +
       				lexer = lexers.Fallback

     

       287
       287
       +
       			}

     

       288
       288
       +
       

     

       289
       289
       +
       			iterator, err := lexer.Tokenise(nil, content)

     

       290
       290
       +
       			if err != nil {

     

       291
       291
       +
       				p.logger.Error("chroma tokenize", "err", "err")

     

       292
       292
       +
       				return ""

     

       293
       293
       +
       			}

     

       294
       294
       +
       

     

       295
       295
       +
       			var code bytes.Buffer

     

       296
       296
       +
       			err = formatter.Format(&code, style, iterator)

     

       297
       297
       +
       			if err != nil {

     

       298
       298
       +
       				p.logger.Error("chroma format", "err", "err")

     

       299
       299
       +
       				return ""

     

       300
       300
       +
       			}

     

       301
       301
       +
       

     

       302
       302
       +
       			return code.String()

     

       303
       303
       +
       		},

     

       304
       304
       +
       		"trimUriScheme": func(text string) string {

     

       305
       305
       +
       			text = strings.TrimPrefix(text, "https://")

     

       306
       306
       +
       			text = strings.TrimPrefix(text, "http://")

     

       307
       307
       +
       			return text

     

       308
       308
       +
       		},

     

       239
       309
        
       		"isNil": func(t any) bool {

     

       240
       310
        
       			// returns false for other "zero" values

     

       241
       311
        
       			return t == nil

     
···

       281
       351
        
       			u, _ := url.PathUnescape(s)

     

       282
       352
        
       			return u

     

       283
       353
        
       		},

     

       284
       284
       -
       

     

       354
       354
       +
       		"safeUrl": func(s string) template.URL {

     

       355
       355
       +
       			return template.URL(s)

     

       356
       356
       +
       		},

     

       285
       357
        
       		"tinyAvatar": func(handle string) string {

     

       286
       358
        
       			return p.AvatarUrl(handle, "tiny")

     

       287
       359
        
       		},

     
···

       297
       369
        
       		},

     

       298
       370
        
       

     

       299
       371
        
       		"normalizeForHtmlId": func(s string) string {

     

       300
       300
       -
       			// TODO: extend this to handle other cases?

     

       301
       301
       -
       			return strings.ReplaceAll(s, ":", "_")

     

       372
       372
       +
       			normalized := strings.ReplaceAll(s, ":", "_")

     

       373
       373
       +
       			normalized = strings.ReplaceAll(normalized, ".", "_")

     

       374
       374
       +
       			return normalized

     

       302
       375
        
       		},

     

       303
       376
        
       		"sshFingerprint": func(pubKey string) string {

     

       304
       377
        
       			fp, err := crypto.SSHFingerprint(pubKey)

     
···

       310
       383
        
       	}

     

       311
       384
        
       }

     

       312
       385
        
       

     

       386
       386
       +
       func (p *Pages) resolveDid(did string) string {

     

       387
       387
       +
       	identity, err := p.resolver.ResolveIdent(context.Background(), did)

     

       388
       388
       +
       

     

       389
       389
       +
       	if err != nil {

     

       390
       390
       +
       		return did

     

       391
       391
       +
       	}

     

       392
       392
       +
       

     

       393
       393
       +
       	if identity.Handle.IsInvalidHandle() {

     

       394
       394
       +
       		return "handle.invalid"

     

       395
       395
       +
       	}

     

       396
       396
       +
       

     

       397
       397
       +
       	return identity.Handle.String()

     

       398
       398
       +
       }

     

       399
       399
       +
       

     

       313
       400
        
       func (p *Pages) AvatarUrl(handle, size string) string {

     

       314
       401
        
       	handle = strings.TrimPrefix(handle, "@")

     

       402
       402
       +
       

     

       403
       403
       +
       	handle = p.resolveDid(handle)

     

       315
       404
        
       

     

       316
       405
        
       	secret := p.avatar.SharedSecret

     

       317
       406
        
       	h := hmac.New(sha256.New, []byte(secret))

+111

appview/pages/markup/extension/atlink.go

···

       1
       1
       +
       // heavily inspired by: https://github.com/kaleocheng/goldmark-extensions

     

       2
       2
       +
       

     

       3
       3
       +
       package extension

     

       4
       4
       +
       

     

       5
       5
       +
       import (

     

       6
       6
       +
       	"regexp"

     

       7
       7
       +
       

     

       8
       8
       +
       	"github.com/yuin/goldmark"

     

       9
       9
       +
       	"github.com/yuin/goldmark/ast"

     

       10
       10
       +
       	"github.com/yuin/goldmark/parser"

     

       11
       11
       +
       	"github.com/yuin/goldmark/renderer"

     

       12
       12
       +
       	"github.com/yuin/goldmark/renderer/html"

     

       13
       13
       +
       	"github.com/yuin/goldmark/text"

     

       14
       14
       +
       	"github.com/yuin/goldmark/util"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       // An AtNode struct represents an AtNode

     

       18
       18
       +
       type AtNode struct {

     

       19
       19
       +
       	Handle string

     

       20
       20
       +
       	ast.BaseInline

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       var _ ast.Node = &AtNode{}

     

       24
       24
       +
       

     

       25
       25
       +
       // Dump implements Node.Dump.

     

       26
       26
       +
       func (n *AtNode) Dump(source []byte, level int) {

     

       27
       27
       +
       	ast.DumpHelper(n, source, level, nil, nil)

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       // KindAt is a NodeKind of the At node.

     

       31
       31
       +
       var KindAt = ast.NewNodeKind("At")

     

       32
       32
       +
       

     

       33
       33
       +
       // Kind implements Node.Kind.

     

       34
       34
       +
       func (n *AtNode) Kind() ast.NodeKind {

     

       35
       35
       +
       	return KindAt

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       var atRegexp = regexp.MustCompile(`(^|\s|\()(@)([a-zA-Z0-9.-]+)(\b)`)

     

       39
       39
       +
       

     

       40
       40
       +
       type atParser struct{}

     

       41
       41
       +
       

     

       42
       42
       +
       // NewAtParser return a new InlineParser that parses

     

       43
       43
       +
       // at expressions.

     

       44
       44
       +
       func NewAtParser() parser.InlineParser {

     

       45
       45
       +
       	return &atParser{}

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       func (s *atParser) Trigger() []byte {

     

       49
       49
       +
       	return []byte{'@'}

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       func (s *atParser) Parse(parent ast.Node, block text.Reader, pc parser.Context) ast.Node {

     

       53
       53
       +
       	line, segment := block.PeekLine()

     

       54
       54
       +
       	m := atRegexp.FindSubmatchIndex(line)

     

       55
       55
       +
       	if m == nil {

     

       56
       56
       +
       		return nil

     

       57
       57
       +
       	}

     

       58
       58
       +
       	atSegment := text.NewSegment(segment.Start, segment.Start+m[1])

     

       59
       59
       +
       	block.Advance(m[1])

     

       60
       60
       +
       	node := &AtNode{}

     

       61
       61
       +
       	node.AppendChild(node, ast.NewTextSegment(atSegment))

     

       62
       62
       +
       	node.Handle = string(atSegment.Value(block.Source())[1:])

     

       63
       63
       +
       	return node

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

       66
       66
       +
       // atHtmlRenderer is a renderer.NodeRenderer implementation that

     

       67
       67
       +
       // renders At nodes.

     

       68
       68
       +
       type atHtmlRenderer struct {

     

       69
       69
       +
       	html.Config

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       // NewAtHTMLRenderer returns a new AtHTMLRenderer.

     

       73
       73
       +
       func NewAtHTMLRenderer(opts ...html.Option) renderer.NodeRenderer {

     

       74
       74
       +
       	r := &atHtmlRenderer{

     

       75
       75
       +
       		Config: html.NewConfig(),

     

       76
       76
       +
       	}

     

       77
       77
       +
       	for _, opt := range opts {

     

       78
       78
       +
       		opt.SetHTMLOption(&r.Config)

     

       79
       79
       +
       	}

     

       80
       80
       +
       	return r

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       // RegisterFuncs implements renderer.NodeRenderer.RegisterFuncs.

     

       84
       84
       +
       func (r *atHtmlRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {

     

       85
       85
       +
       	reg.Register(KindAt, r.renderAt)

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func (r *atHtmlRenderer) renderAt(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       89
       89
       +
       	if entering {

     

       90
       90
       +
       		w.WriteString(`<a href="/@`)

     

       91
       91
       +
       		w.WriteString(n.(*AtNode).Handle)

     

       92
       92
       +
       		w.WriteString(`" class="mention font-bold">`)

     

       93
       93
       +
       	} else {

     

       94
       94
       +
       		w.WriteString("</a>")

     

       95
       95
       +
       	}

     

       96
       96
       +
       	return ast.WalkContinue, nil

     

       97
       97
       +
       }

     

       98
       98
       +
       

     

       99
       99
       +
       type atExt struct{}

     

       100
       100
       +
       

     

       101
       101
       +
       // At is an extension that allow you to use at expression like '@user.bsky.social' .

     

       102
       102
       +
       var AtExt = &atExt{}

     

       103
       103
       +
       

     

       104
       104
       +
       func (e *atExt) Extend(m goldmark.Markdown) {

     

       105
       105
       +
       	m.Parser().AddOptions(parser.WithInlineParsers(

     

       106
       106
       +
       		util.Prioritized(NewAtParser(), 500),

     

       107
       107
       +
       	))

     

       108
       108
       +
       	m.Renderer().AddOptions(renderer.WithNodeRenderers(

     

       109
       109
       +
       		util.Prioritized(NewAtHTMLRenderer(), 500),

     

       110
       110
       +
       	))

     

       111
       111
       +
       }

+11 -4

appview/pages/markup/markdown.go

···

       12
       12
        
       

     

       13
       13
        
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       14
       14
        
       	"github.com/alecthomas/chroma/v2/styles"

     

       15
       15
       -
       	treeblood "github.com/wyatt915/goldmark-treeblood"

     

       16
       15
        
       	"github.com/yuin/goldmark"

     

       17
       16
        
       	highlighting "github.com/yuin/goldmark-highlighting/v2"

     

       18
       17
        
       	"github.com/yuin/goldmark/ast"

     
···

       25
       24
        
       	htmlparse "golang.org/x/net/html"

     

       26
       25
        
       

     

       27
       26
        
       	"tangled.org/core/api/tangled"

     

       27
       27
       +
       	textension "tangled.org/core/appview/pages/markup/extension"

     

       28
       28
        
       	"tangled.org/core/appview/pages/repoinfo"

     

       29
       29
        
       )

     

       30
       30
        
       

     
···

       50
       50
        
       	Files        fs.FS

     

       51
       51
        
       }

     

       52
       52
        
       

     

       53
       53
       -
       func (rctx *RenderContext) RenderMarkdown(source string) string {

     

       53
       53
       +
       func NewMarkdown() goldmark.Markdown {

     

       54
       54
        
       	md := goldmark.New(

     

       55
       55
        
       		goldmark.WithExtensions(

     

       56
       56
        
       			extension.GFM,

     
···

       64
       64
        
       			extension.NewFootnote(

     

       65
       65
        
       				extension.WithFootnoteIDPrefix([]byte("footnote")),

     

       66
       66
        
       			),

     

       67
       67
       -
       			treeblood.MathML(),

     

       68
       67
        
       			callout.CalloutExtention,

     

       68
       68
       +
       			textension.AtExt,

     

       69
       69
        
       		),

     

       70
       70
        
       		goldmark.WithParserOptions(

     

       71
       71
        
       			parser.WithAutoHeadingID(),

     

       72
       72
        
       		),

     

       73
       73
        
       		goldmark.WithRendererOptions(html.WithUnsafe()),

     

       74
       74
        
       	)

     

       75
       75
       +
       	return md

     

       76
       76
       +
       }

     

       75
       77
        
       

     

       78
       78
       +
       func (rctx *RenderContext) RenderMarkdown(source string) string {

     

       79
       79
       +
       	return rctx.RenderMarkdownWith(source, NewMarkdown())

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       func (rctx *RenderContext) RenderMarkdownWith(source string, md goldmark.Markdown) string {

     

       76
       83
        
       	if rctx != nil {

     

       77
       84
        
       		var transformers []util.PrioritizedValue

     

       78
       85
        
       

     
···

       240
       247
        
       	repoName := fmt.Sprintf("%s/%s", rctx.RepoInfo.OwnerDid, rctx.RepoInfo.Name)

     

       241
       248
        
       

     

       242
       249
        
       	query := fmt.Sprintf("repo=%s&ref=%s&path=%s&raw=true",

     

       243
       243
       -
       		url.PathEscape(repoName), url.PathEscape(rctx.RepoInfo.Ref), actualPath)

     

       250
       250
       +
       		url.QueryEscape(repoName), url.QueryEscape(rctx.RepoInfo.Ref), actualPath)

     

       244
       251
        
       

     

       245
       252
        
       	parsedURL := &url.URL{

     

       246
       253
        
       		Scheme:   scheme,

+124

appview/pages/markup/reference_link.go

···

       1
       1
       +
       package markup

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"maps"

     

       5
       5
       +
       	"net/url"

     

       6
       6
       +
       	"path"

     

       7
       7
       +
       	"slices"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

       11
       11
       +
       	"github.com/yuin/goldmark/ast"

     

       12
       12
       +
       	"github.com/yuin/goldmark/text"

     

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

     

       14
       14
       +
       	textension "tangled.org/core/appview/pages/markup/extension"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       // FindReferences collects all links referencing tangled-related objects

     

       18
       18
       +
       // like issues, PRs, comments or even @-mentions

     

       19
       19
       +
       // This funciton doesn't actually check for the existence of records in the DB

     

       20
       20
       +
       // or the PDS; it merely returns a list of what are presumed to be references.

     

       21
       21
       +
       func FindReferences(baseUrl string, source string) ([]string, []models.ReferenceLink) {

     

       22
       22
       +
       	var (

     

       23
       23
       +
       		refLinkSet  = make(map[models.ReferenceLink]struct{})

     

       24
       24
       +
       		mentionsSet = make(map[string]struct{})

     

       25
       25
       +
       		md          = NewMarkdown()

     

       26
       26
       +
       		sourceBytes = []byte(source)

     

       27
       27
       +
       		root        = md.Parser().Parse(text.NewReader(sourceBytes))

     

       28
       28
       +
       	)

     

       29
       29
       +
       	// trim url scheme. the SSL shouldn't matter

     

       30
       30
       +
       	baseUrl = strings.TrimPrefix(baseUrl, "https://")

     

       31
       31
       +
       	baseUrl = strings.TrimPrefix(baseUrl, "http://")

     

       32
       32
       +
       

     

       33
       33
       +
       	ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       34
       34
       +
       		if !entering {

     

       35
       35
       +
       			return ast.WalkContinue, nil

     

       36
       36
       +
       		}

     

       37
       37
       +
       		switch n.Kind() {

     

       38
       38
       +
       		case textension.KindAt:

     

       39
       39
       +
       			handle := n.(*textension.AtNode).Handle

     

       40
       40
       +
       			mentionsSet[handle] = struct{}{}

     

       41
       41
       +
       			return ast.WalkSkipChildren, nil

     

       42
       42
       +
       		case ast.KindLink:

     

       43
       43
       +
       			dest := string(n.(*ast.Link).Destination)

     

       44
       44
       +
       			ref := parseTangledLink(baseUrl, dest)

     

       45
       45
       +
       			if ref != nil {

     

       46
       46
       +
       				refLinkSet[*ref] = struct{}{}

     

       47
       47
       +
       			}

     

       48
       48
       +
       			return ast.WalkSkipChildren, nil

     

       49
       49
       +
       		case ast.KindAutoLink:

     

       50
       50
       +
       			an := n.(*ast.AutoLink)

     

       51
       51
       +
       			if an.AutoLinkType == ast.AutoLinkURL {

     

       52
       52
       +
       				dest := string(an.URL(sourceBytes))

     

       53
       53
       +
       				ref := parseTangledLink(baseUrl, dest)

     

       54
       54
       +
       				if ref != nil {

     

       55
       55
       +
       					refLinkSet[*ref] = struct{}{}

     

       56
       56
       +
       				}

     

       57
       57
       +
       			}

     

       58
       58
       +
       			return ast.WalkSkipChildren, nil

     

       59
       59
       +
       		}

     

       60
       60
       +
       		return ast.WalkContinue, nil

     

       61
       61
       +
       	})

     

       62
       62
       +
       	mentions := slices.Collect(maps.Keys(mentionsSet))

     

       63
       63
       +
       	references := slices.Collect(maps.Keys(refLinkSet))

     

       64
       64
       +
       	return mentions, references

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       func parseTangledLink(baseHost string, urlStr string) *models.ReferenceLink {

     

       68
       68
       +
       	u, err := url.Parse(urlStr)

     

       69
       69
       +
       	if err != nil {

     

       70
       70
       +
       		return nil

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	if u.Host != "" && !strings.EqualFold(u.Host, baseHost) {

     

       74
       74
       +
       		return nil

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	p := path.Clean(u.Path)

     

       78
       78
       +
       	parts := strings.FieldsFunc(p, func(r rune) bool { return r == '/' })

     

       79
       79
       +
       	if len(parts) < 4 {

     

       80
       80
       +
       		// need at least: handle / repo / kind / id

     

       81
       81
       +
       		return nil

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	var (

     

       85
       85
       +
       		handle     = parts[0]

     

       86
       86
       +
       		repo       = parts[1]

     

       87
       87
       +
       		kindSeg    = parts[2]

     

       88
       88
       +
       		subjectSeg = parts[3]

     

       89
       89
       +
       	)

     

       90
       90
       +
       

     

       91
       91
       +
       	handle = strings.TrimPrefix(handle, "@")

     

       92
       92
       +
       

     

       93
       93
       +
       	var kind models.RefKind

     

       94
       94
       +
       	switch kindSeg {

     

       95
       95
       +
       	case "issues":

     

       96
       96
       +
       		kind = models.RefKindIssue

     

       97
       97
       +
       	case "pulls":

     

       98
       98
       +
       		kind = models.RefKindPull

     

       99
       99
       +
       	default:

     

       100
       100
       +
       		return nil

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	subjectId, err := strconv.Atoi(subjectSeg)

     

       104
       104
       +
       	if err != nil {

     

       105
       105
       +
       		return nil

     

       106
       106
       +
       	}

     

       107
       107
       +
       	var commentId *int

     

       108
       108
       +
       	if u.Fragment != "" {

     

       109
       109
       +
       		if strings.HasPrefix(u.Fragment, "comment-") {

     

       110
       110
       +
       			commentIdStr := u.Fragment[len("comment-"):]

     

       111
       111
       +
       			if id, err := strconv.Atoi(commentIdStr); err == nil {

     

       112
       112
       +
       				commentId = &id

     

       113
       113
       +
       			}

     

       114
       114
       +
       		}

     

       115
       115
       +
       	}

     

       116
       116
       +
       

     

       117
       117
       +
       	return &models.ReferenceLink{

     

       118
       118
       +
       		Handle:    handle,

     

       119
       119
       +
       		Repo:      repo,

     

       120
       120
       +
       		Kind:      kind,

     

       121
       121
       +
       		SubjectId: subjectId,

     

       122
       122
       +
       		CommentId: commentId,

     

       123
       123
       +
       	}

     

       124
       124
       +
       }

+42

appview/pages/markup/reference_link_test.go

···

       1
       1
       +
       package markup_test

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       

     

       6
       6
       +
       	"github.com/stretchr/testify/assert"

     

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

     

       8
       8
       +
       	"tangled.org/core/appview/pages/markup"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       func TestMarkupParsing(t *testing.T) {

     

       12
       12
       +
       	tests := []struct {

     

       13
       13
       +
       		name         string

     

       14
       14
       +
       		source       string

     

       15
       15
       +
       		wantHandles  []string

     

       16
       16
       +
       		wantRefLinks []models.ReferenceLink

     

       17
       17
       +
       	}{

     

       18
       18
       +
       		{

     

       19
       19
       +
       			name:        "normal link",

     

       20
       20
       +
       			source:      `[link](http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1)`,

     

       21
       21
       +
       			wantHandles: make([]string, 0),

     

       22
       22
       +
       			wantRefLinks: []models.ReferenceLink{

     

       23
       23
       +
       				{Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil},

     

       24
       24
       +
       			},

     

       25
       25
       +
       		},

     

       26
       26
       +
       		{

     

       27
       27
       +
       			name:        "commonmark style autolink",

     

       28
       28
       +
       			source:      `<http://127.0.0.1:3000/alice.pds.tngl.boltless.dev/coolproj/issues/1>`,

     

       29
       29
       +
       			wantHandles: make([]string, 0),

     

       30
       30
       +
       			wantRefLinks: []models.ReferenceLink{

     

       31
       31
       +
       				{Handle: "alice.pds.tngl.boltless.dev", Repo: "coolproj", Kind: models.RefKindIssue, SubjectId: 1, CommentId: nil},

     

       32
       32
       +
       			},

     

       33
       33
       +
       		},

     

       34
       34
       +
       	}

     

       35
       35
       +
       	for _, tt := range tests {

     

       36
       36
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       37
       37
       +
       			handles, refLinks := markup.FindReferences("http://127.0.0.1:3000", tt.source)

     

       38
       38
       +
       			assert.ElementsMatch(t, tt.wantHandles, handles)

     

       39
       39
       +
       			assert.ElementsMatch(t, tt.wantRefLinks, refLinks)

     

       40
       40
       +
       		})

     

       41
       41
       +
       	}

     

       42
       42
       +
       }

appview/pages/markup/sanitizer.go

···

       77
       77
        
       	policy.AllowAttrs("class").Matching(regexp.MustCompile(`heading`)).OnElements("h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8")

     

       78
       78
        
       	policy.AllowAttrs("class").Matching(regexp.MustCompile(strings.Join(slices.Collect(maps.Values(chroma.StandardTypes)), "|"))).OnElements("span")

     

       79
       79
        
       

     

       80
       80
       +
       	// at-mentions

     

       81
       81
       +
       	policy.AllowAttrs("class").Matching(regexp.MustCompile(`mention`)).OnElements("a")

     

       82
       82
       +
       

     

       80
       83
        
       	// centering content

     

       81
       84
        
       	policy.AllowElements("center")

     

       82
       85

+75 -148

appview/pages/pages.go

···

       1
       1
        
       package pages

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"bytes"

     

       5
       4
        
       	"crypto/sha256"

     

       6
       5
        
       	"embed"

     

       7
       6
        
       	"encoding/hex"

     
···

       15
       14
        
       	"path/filepath"

     

       16
       15
        
       	"strings"

     

       17
       16
        
       	"sync"

     

       17
       17
       +
       	"time"

     

       18
       18
        
       

     

       19
       19
        
       	"tangled.org/core/api/tangled"

     

       20
       20
        
       	"tangled.org/core/appview/commitverify"

     
···

       28
       28
        
       	"tangled.org/core/patchutil"

     

       29
       29
        
       	"tangled.org/core/types"

     

       30
       30
        
       

     

       31
       31
       -
       	"github.com/alecthomas/chroma/v2"

     

       32
       32
       -
       	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"

     

       33
       33
       -
       	"github.com/alecthomas/chroma/v2/lexers"

     

       34
       34
       -
       	"github.com/alecthomas/chroma/v2/styles"

     

       35
       31
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

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

     

       37
       33
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       38
       38
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       39
       34
        
       )

     

       40
       35
        
       

     

       41
       36
        
       //go:embed templates/* static legal

     
···

       221
       216
        
       

     

       222
       217
        
       type LoginParams struct {

     

       223
       218
        
       	ReturnUrl string

     

       219
       219
       +
       	ErrorCode string

     

       224
       220
        
       }

     

       225
       221
        
       

     

       226
       222
        
       func (p *Pages) Login(w io.Writer, params LoginParams) error {

     
···

       410
       406
        
       type KnotsParams struct {

     

       411
       407
        
       	LoggedInUser  *oauth.User

     

       412
       408
        
       	Registrations []models.Registration

     

       409
       409
       +
       	Tabs          []map[string]any

     

       410
       410
       +
       	Tab           string

     

       413
       411
        
       }

     

       414
       412
        
       

     

       415
       413
        
       func (p *Pages) Knots(w io.Writer, params KnotsParams) error {

     
···

       422
       420
        
       	Members      []string

     

       423
       421
        
       	Repos        map[string][]models.Repo

     

       424
       422
        
       	IsOwner      bool

     

       423
       423
       +
       	Tabs         []map[string]any

     

       424
       424
       +
       	Tab          string

     

       425
       425
        
       }

     

       426
       426
        
       

     

       427
       427
        
       func (p *Pages) Knot(w io.Writer, params KnotParams) error {

     
···

       439
       439
        
       type SpindlesParams struct {

     

       440
       440
        
       	LoggedInUser *oauth.User

     

       441
       441
        
       	Spindles     []models.Spindle

     

       442
       442
       +
       	Tabs         []map[string]any

     

       443
       443
       +
       	Tab          string

     

       442
       444
        
       }

     

       443
       445
        
       

     

       444
       446
        
       func (p *Pages) Spindles(w io.Writer, params SpindlesParams) error {

     
···

       447
       449
        
       

     

       448
       450
        
       type SpindleListingParams struct {

     

       449
       451
        
       	models.Spindle

     

       452
       452
       +
       	Tabs []map[string]any

     

       453
       453
       +
       	Tab  string

     

       450
       454
        
       }

     

       451
       455
        
       

     

       452
       456
        
       func (p *Pages) SpindleListing(w io.Writer, params SpindleListingParams) error {

     
···

       458
       462
        
       	Spindle      models.Spindle

     

       459
       463
        
       	Members      []string

     

       460
       464
        
       	Repos        map[string][]models.Repo

     

       465
       465
       +
       	Tabs         []map[string]any

     

       466
       466
       +
       	Tab          string

     

       461
       467
        
       }

     

       462
       468
        
       

     

       463
       469
        
       func (p *Pages) SpindleDashboard(w io.Writer, params SpindleDashboardParams) error {

     
···

       485
       491
        
       

     

       486
       492
        
       type ProfileCard struct {

     

       487
       493
        
       	UserDid      string

     

       488
       488
       -
       	UserHandle   string

     

       489
       494
        
       	FollowStatus models.FollowStatus

     

       490
       495
        
       	Punchcard    *models.Punchcard

     

       491
       496
        
       	Profile      *models.Profile

     
···

       628
       633
        
       	return p.executePlain("user/fragments/editPins", w, params)

     

       629
       634
        
       }

     

       630
       635
        
       

     

       631
       631
       -
       type RepoStarFragmentParams struct {

     

       636
       636
       +
       type StarBtnFragmentParams struct {

     

       632
       637
        
       	IsStarred bool

     

       633
       633
       -
       	RepoAt    syntax.ATURI

     

       634
       634
       -
       	Stats     models.RepoStats

     

       635
       635
       -
       }

     

       636
       636
       -
       

     

       637
       637
       -
       func (p *Pages) RepoStarFragment(w io.Writer, params RepoStarFragmentParams) error {

     

       638
       638
       -
       	return p.executePlain("repo/fragments/repoStar", w, params)

     

       639
       639
       -
       }

     

       640
       640
       -
       

     

       641
       641
       -
       type RepoDescriptionParams struct {

     

       642
       642
       -
       	RepoInfo repoinfo.RepoInfo

     

       643
       643
       -
       }

     

       644
       644
       -
       

     

       645
       645
       -
       func (p *Pages) EditRepoDescriptionFragment(w io.Writer, params RepoDescriptionParams) error {

     

       646
       646
       -
       	return p.executePlain("repo/fragments/editRepoDescription", w, params)

     

       638
       638
       +
       	SubjectAt syntax.ATURI

     

       639
       639
       +
       	StarCount int

     

       647
       640
        
       }

     

       648
       641
        
       

     

       649
       649
       -
       func (p *Pages) RepoDescriptionFragment(w io.Writer, params RepoDescriptionParams) error {

     

       650
       650
       -
       	return p.executePlain("repo/fragments/repoDescription", w, params)

     

       642
       642
       +
       func (p *Pages) StarBtnFragment(w io.Writer, params StarBtnFragmentParams) error {

     

       643
       643
       +
       	return p.executePlain("fragments/starBtn", w, params)

     

       651
       644
        
       }

     

       652
       645
        
       

     

       653
       646
        
       type RepoIndexParams struct {

     
···

       655
       648
        
       	RepoInfo      repoinfo.RepoInfo

     

       656
       649
        
       	Active        string

     

       657
       650
        
       	TagMap        map[string][]string

     

       658
       658
       -
       	CommitsTrunc  []*object.Commit

     

       651
       651
       +
       	CommitsTrunc  []types.Commit

     

       659
       652
        
       	TagsTrunc     []*types.TagReference

     

       660
       653
        
       	BranchesTrunc []types.Branch

     

       661
       654
        
       	// ForkInfo           *types.ForkInfo

     

       662
       662
       -
       	HTMLReadme         template.HTML

     

       663
       663
       -
       	Raw                bool

     

       664
       664
       -
       	EmailToDidOrHandle map[string]string

     

       665
       665
       -
       	VerifiedCommits    commitverify.VerifiedCommits

     

       666
       666
       -
       	Languages          []types.RepoLanguageDetails

     

       667
       667
       -
       	Pipelines          map[string]models.Pipeline

     

       668
       668
       -
       	NeedsKnotUpgrade   bool

     

       655
       655
       +
       	HTMLReadme       template.HTML

     

       656
       656
       +
       	Raw              bool

     

       657
       657
       +
       	EmailToDid       map[string]string

     

       658
       658
       +
       	VerifiedCommits  commitverify.VerifiedCommits

     

       659
       659
       +
       	Languages        []types.RepoLanguageDetails

     

       660
       660
       +
       	Pipelines        map[string]models.Pipeline

     

       661
       661
       +
       	NeedsKnotUpgrade bool

     

       669
       662
        
       	types.RepoIndexResponse

     

       670
       663
        
       }

     

       671
       664
        
       

     
···

       700
       693
        
       }

     

       701
       694
        
       

     

       702
       695
        
       type RepoLogParams struct {

     

       703
       703
       -
       	LoggedInUser *oauth.User

     

       704
       704
       -
       	RepoInfo     repoinfo.RepoInfo

     

       705
       705
       -
       	TagMap       map[string][]string

     

       696
       696
       +
       	LoggedInUser    *oauth.User

     

       697
       697
       +
       	RepoInfo        repoinfo.RepoInfo

     

       698
       698
       +
       	TagMap          map[string][]string

     

       699
       699
       +
       	Active          string

     

       700
       700
       +
       	EmailToDid      map[string]string

     

       701
       701
       +
       	VerifiedCommits commitverify.VerifiedCommits

     

       702
       702
       +
       	Pipelines       map[string]models.Pipeline

     

       703
       703
       +
       

     

       706
       704
        
       	types.RepoLogResponse

     

       707
       707
       -
       	Active             string

     

       708
       708
       -
       	EmailToDidOrHandle map[string]string

     

       709
       709
       -
       	VerifiedCommits    commitverify.VerifiedCommits

     

       710
       710
       -
       	Pipelines          map[string]models.Pipeline

     

       711
       705
        
       }

     

       712
       706
        
       

     

       713
       707
        
       func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {

     
···

       716
       710
        
       }

     

       717
       711
        
       

     

       718
       712
        
       type RepoCommitParams struct {

     

       719
       719
       -
       	LoggedInUser       *oauth.User

     

       720
       720
       -
       	RepoInfo           repoinfo.RepoInfo

     

       721
       721
       -
       	Active             string

     

       722
       722
       -
       	EmailToDidOrHandle map[string]string

     

       723
       723
       -
       	Pipeline           *models.Pipeline

     

       724
       724
       -
       	DiffOpts           types.DiffOpts

     

       713
       713
       +
       	LoggedInUser *oauth.User

     

       714
       714
       +
       	RepoInfo     repoinfo.RepoInfo

     

       715
       715
       +
       	Active       string

     

       716
       716
       +
       	EmailToDid   map[string]string

     

       717
       717
       +
       	Pipeline     *models.Pipeline

     

       718
       718
       +
       	DiffOpts     types.DiffOpts

     

       725
       719
        
       

     

       726
       720
        
       	// singular because it's always going to be just one

     

       727
       721
        
       	VerifiedCommit commitverify.VerifiedCommits

     
···

       753
       747
        
       func (r RepoTreeParams) TreeStats() RepoTreeStats {

     

       754
       748
        
       	numFolders, numFiles := 0, 0

     

       755
       749
        
       	for _, f := range r.Files {

     

       756
       756
       -
       		if !f.IsFile {

     

       750
       750
       +
       		if !f.IsFile() {

     

       757
       751
        
       			numFolders += 1

     

       758
       758
       -
       		} else if f.IsFile {

     

       752
       752
       +
       		} else if f.IsFile() {

     

       759
       753
        
       			numFiles += 1

     

       760
       754
        
       		}

     

       761
       755
        
       	}

     
···

       826
       820
        
       }

     

       827
       821
        
       

     

       828
       822
        
       type RepoBlobParams struct {

     

       829
       829
       -
       	LoggedInUser     *oauth.User

     

       830
       830
       -
       	RepoInfo         repoinfo.RepoInfo

     

       831
       831
       -
       	Active           string

     

       832
       832
       -
       	Unsupported      bool

     

       833
       833
       -
       	IsImage          bool

     

       834
       834
       -
       	IsVideo          bool

     

       835
       835
       -
       	ContentSrc       string

     

       836
       836
       -
       	BreadCrumbs      [][]string

     

       837
       837
       -
       	ShowRendered     bool

     

       838
       838
       -
       	RenderToggle     bool

     

       839
       839
       -
       	RenderedContents template.HTML

     

       823
       823
       +
       	LoggedInUser *oauth.User

     

       824
       824
       +
       	RepoInfo     repoinfo.RepoInfo

     

       825
       825
       +
       	Active       string

     

       826
       826
       +
       	BreadCrumbs  [][]string

     

       827
       827
       +
       	BlobView     models.BlobView

     

       840
       828
        
       	*tangled.RepoBlob_Output

     

       841
       841
       -
       	// Computed fields for template compatibility

     

       842
       842
       -
       	Contents string

     

       843
       843
       -
       	Lines    int

     

       844
       844
       -
       	SizeHint uint64

     

       845
       845
       -
       	IsBinary bool

     

       846
       829
        
       }

     

       847
       830
        
       

     

       848
       831
        
       func (p *Pages) RepoBlob(w io.Writer, params RepoBlobParams) error {

     

       849
       849
       -
       	var style *chroma.Style = styles.Get("catpuccin-latte")

     

       850
       850
       -
       

     

       851
       851
       -
       	if params.ShowRendered {

     

       852
       852
       -
       		switch markup.GetFormat(params.Path) {

     

       853
       853
       -
       		case markup.FormatMarkdown:

     

       854
       854
       -
       			p.rctx.RepoInfo = params.RepoInfo

     

       855
       855
       -
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       856
       856
       -
       			htmlString := p.rctx.RenderMarkdown(params.Contents)

     

       857
       857
       -
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       858
       858
       -
       			params.RenderedContents = template.HTML(sanitized)

     

       859
       859
       -
       		}

     

       832
       832
       +
       	switch params.BlobView.ContentType {

     

       833
       833
       +
       	case models.BlobContentTypeMarkup:

     

       834
       834
       +
       		p.rctx.RepoInfo = params.RepoInfo

     

       860
       835
        
       	}

     

       861
       836
        
       

     

       862
       862
       -
       	c := params.Contents

     

       863
       863
       -
       	formatter := chromahtml.New(

     

       864
       864
       -
       		chromahtml.InlineCode(false),

     

       865
       865
       -
       		chromahtml.WithLineNumbers(true),

     

       866
       866
       -
       		chromahtml.WithLinkableLineNumbers(true, "L"),

     

       867
       867
       -
       		chromahtml.Standalone(false),

     

       868
       868
       -
       		chromahtml.WithClasses(true),

     

       869
       869
       -
       	)

     

       870
       870
       -
       

     

       871
       871
       -
       	lexer := lexers.Get(filepath.Base(params.Path))

     

       872
       872
       -
       	if lexer == nil {

     

       873
       873
       -
       		lexer = lexers.Fallback

     

       874
       874
       -
       	}

     

       875
       875
       -
       

     

       876
       876
       -
       	iterator, err := lexer.Tokenise(nil, c)

     

       877
       877
       -
       	if err != nil {

     

       878
       878
       -
       		return fmt.Errorf("chroma tokenize: %w", err)

     

       879
       879
       -
       	}

     

       880
       880
       -
       

     

       881
       881
       -
       	var code bytes.Buffer

     

       882
       882
       -
       	err = formatter.Format(&code, style, iterator)

     

       883
       883
       -
       	if err != nil {

     

       884
       884
       -
       		return fmt.Errorf("chroma format: %w", err)

     

       885
       885
       -
       	}

     

       886
       886
       -
       

     

       887
       887
       -
       	params.Contents = code.String()

     

       888
       837
        
       	params.Active = "overview"

     

       889
       838
        
       	return p.executeRepo("repo/blob", w, params)

     

       890
       839
        
       }

     

       891
       840
        
       

     

       892
       841
        
       type Collaborator struct {

     

       893
       893
       -
       	Did    string

     

       894
       894
       -
       	Handle string

     

       895
       895
       -
       	Role   string

     

       842
       842
       +
       	Did  string

     

       843
       843
       +
       	Role string

     

       896
       844
        
       }

     

       897
       845
        
       

     

       898
       846
        
       type RepoSettingsParams struct {

     
···

       967
       915
        
       	RepoInfo        repoinfo.RepoInfo

     

       968
       916
        
       	Active          string

     

       969
       917
        
       	Issues          []models.Issue

     

       918
       918
       +
       	IssueCount      int

     

       970
       919
        
       	LabelDefs       map[string]*models.LabelDefinition

     

       971
       920
        
       	Page            pagination.Page

     

       972
       921
        
       	FilteringByOpen bool

     

       922
       922
       +
       	FilterQuery     string

     

       973
       923
        
       }

     

       974
       924
        
       

     

       975
       925
        
       func (p *Pages) RepoIssues(w io.Writer, params RepoIssuesParams) error {

     
···

       983
       933
        
       	Active       string

     

       984
       934
        
       	Issue        *models.Issue

     

       985
       935
        
       	CommentList  []models.CommentListItem

     

       936
       936
       +
       	Backlinks    []models.RichReferenceLink

     

       986
       937
        
       	LabelDefs    map[string]*models.LabelDefinition

     

       987
       938
        
       

     

       988
       939
        
       	OrderedReactionKinds []models.ReactionKind

     
···

       1100
       1051
        
       	Pulls        []*models.Pull

     

       1101
       1052
        
       	Active       string

     

       1102
       1053
        
       	FilteringBy  models.PullState

     

       1054
       1054
       +
       	FilterQuery  string

     

       1103
       1055
        
       	Stacks       map[string]models.Stack

     

       1104
       1056
        
       	Pipelines    map[string]models.Pipeline

     

       1105
       1057
        
       	LabelDefs    map[string]*models.LabelDefinition

     
···

       1135
       1087
        
       	Pull               *models.Pull

     

       1136
       1088
        
       	Stack              models.Stack

     

       1137
       1089
        
       	AbandonedPulls     []*models.Pull

     

       1090
       1090
       +
       	Backlinks          []models.RichReferenceLink

     

       1138
       1091
        
       	BranchDeleteStatus *models.BranchDeleteStatus

     

       1139
       1092
        
       	MergeCheck         types.MergeCheckResponse

     

       1140
       1093
        
       	ResubmitCheck      ResubmitResult

     
···

       1306
       1259
        
       	return p.executePlain("repo/fragments/compareAllowPull", w, params)

     

       1307
       1260
        
       }

     

       1308
       1261
        
       

     

       1309
       1309
       -
       type RepoCompareDiffParams struct {

     

       1310
       1310
       -
       	LoggedInUser *oauth.User

     

       1311
       1311
       -
       	RepoInfo     repoinfo.RepoInfo

     

       1312
       1312
       -
       	Diff         types.NiceDiff

     

       1262
       1262
       +
       type RepoCompareDiffFragmentParams struct {

     

       1263
       1263
       +
       	Diff     types.NiceDiff

     

       1264
       1264
       +
       	DiffOpts types.DiffOpts

     

       1313
       1265
        
       }

     

       1314
       1266
        
       

     

       1315
       1315
       -
       func (p *Pages) RepoCompareDiff(w io.Writer, params RepoCompareDiffParams) error {

     

       1316
       1316
       -
       	return p.executePlain("repo/fragments/diff", w, []any{params.RepoInfo.FullName, &params.Diff})

     

       1267
       1267
       +
       func (p *Pages) RepoCompareDiffFragment(w io.Writer, params RepoCompareDiffFragmentParams) error {

     

       1268
       1268
       +
       	return p.executePlain("repo/fragments/diff", w, []any{&params.Diff, &params.DiffOpts})

     

       1317
       1269
        
       }

     

       1318
       1270
        
       

     

       1319
       1271
        
       type LabelPanelParams struct {

     
···

       1357
       1309
        
       	Name      string

     

       1358
       1310
        
       	Command   string

     

       1359
       1311
        
       	Collapsed bool

     

       1312
       1312
       +
       	StartTime time.Time

     

       1360
       1313
        
       }

     

       1361
       1314
        
       

     

       1362
       1315
        
       func (p *Pages) LogBlock(w io.Writer, params LogBlockParams) error {

     

       1363
       1316
        
       	return p.executePlain("repo/pipelines/fragments/logBlock", w, params)

     

       1317
       1317
       +
       }

     

       1318
       1318
       +
       

     

       1319
       1319
       +
       type LogBlockEndParams struct {

     

       1320
       1320
       +
       	Id        int

     

       1321
       1321
       +
       	StartTime time.Time

     

       1322
       1322
       +
       	EndTime   time.Time

     

       1323
       1323
       +
       }

     

       1324
       1324
       +
       

     

       1325
       1325
       +
       func (p *Pages) LogBlockEnd(w io.Writer, params LogBlockEndParams) error {

     

       1326
       1326
       +
       	return p.executePlain("repo/pipelines/fragments/logBlockEnd", w, params)

     

       1364
       1327
        
       }

     

       1365
       1328
        
       

     

       1366
       1329
        
       type LogLineParams struct {

     
···

       1422
       1385
        
       	ShowRendered     bool

     

       1423
       1386
        
       	RenderToggle     bool

     

       1424
       1387
        
       	RenderedContents template.HTML

     

       1425
       1425
       -
       	String           models.String

     

       1388
       1388
       +
       	String           *models.String

     

       1426
       1389
        
       	Stats            models.StringStats

     

       1390
       1390
       +
       	IsStarred        bool

     

       1391
       1391
       +
       	StarCount        int

     

       1427
       1392
        
       	Owner            identity.Identity

     

       1428
       1393
        
       }

     

       1429
       1394
        
       

     

       1430
       1395
        
       func (p *Pages) SingleString(w io.Writer, params SingleStringParams) error {

     

       1431
       1431
       -
       	var style *chroma.Style = styles.Get("catpuccin-latte")

     

       1432
       1432
       -
       

     

       1433
       1433
       -
       	if params.ShowRendered {

     

       1434
       1434
       -
       		switch markup.GetFormat(params.String.Filename) {

     

       1435
       1435
       -
       		case markup.FormatMarkdown:

     

       1436
       1436
       -
       			p.rctx.RendererType = markup.RendererTypeRepoMarkdown

     

       1437
       1437
       -
       			htmlString := p.rctx.RenderMarkdown(params.String.Contents)

     

       1438
       1438
       -
       			sanitized := p.rctx.SanitizeDefault(htmlString)

     

       1439
       1439
       -
       			params.RenderedContents = template.HTML(sanitized)

     

       1440
       1440
       -
       		}

     

       1441
       1441
       -
       	}

     

       1442
       1442
       -
       

     

       1443
       1443
       -
       	c := params.String.Contents

     

       1444
       1444
       -
       	formatter := chromahtml.New(

     

       1445
       1445
       -
       		chromahtml.InlineCode(false),

     

       1446
       1446
       -
       		chromahtml.WithLineNumbers(true),

     

       1447
       1447
       -
       		chromahtml.WithLinkableLineNumbers(true, "L"),

     

       1448
       1448
       -
       		chromahtml.Standalone(false),

     

       1449
       1449
       -
       		chromahtml.WithClasses(true),

     

       1450
       1450
       -
       	)

     

       1451
       1451
       -
       

     

       1452
       1452
       -
       	lexer := lexers.Get(filepath.Base(params.String.Filename))

     

       1453
       1453
       -
       	if lexer == nil {

     

       1454
       1454
       -
       		lexer = lexers.Fallback

     

       1455
       1455
       -
       	}

     

       1456
       1456
       -
       

     

       1457
       1457
       -
       	iterator, err := lexer.Tokenise(nil, c)

     

       1458
       1458
       -
       	if err != nil {

     

       1459
       1459
       -
       		return fmt.Errorf("chroma tokenize: %w", err)

     

       1460
       1460
       -
       	}

     

       1461
       1461
       -
       

     

       1462
       1462
       -
       	var code bytes.Buffer

     

       1463
       1463
       -
       	err = formatter.Format(&code, style, iterator)

     

       1464
       1464
       -
       	if err != nil {

     

       1465
       1465
       -
       		return fmt.Errorf("chroma format: %w", err)

     

       1466
       1466
       -
       	}

     

       1467
       1467
       -
       

     

       1468
       1468
       -
       	params.String.Contents = code.String()

     

       1469
       1396
        
       	return p.execute("strings/string", w, params)

     

       1470
       1397
        
       }

     

       1471
       1398

+27 -24

appview/pages/repoinfo/repoinfo.go

···

       4
       4
        
       	"fmt"

     

       5
       5
        
       	"path"

     

       6
       6
        
       	"slices"

     

       7
       7
       -
       	"strings"

     

       8
       7
        
       

     

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

     

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

     

       10
       10
        
       	"tangled.org/core/appview/models"

     

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

     

       12
       12
        
       )

     

       13
       13
        
       

     

       14
       14
       -
       func (r RepoInfo) OwnerWithAt() string {

     

       14
       14
       +
       func (r RepoInfo) owner() string {

     

       15
       15
        
       	if r.OwnerHandle != "" {

     

       16
       16
       -
       		return fmt.Sprintf("@%s", r.OwnerHandle)

     

       16
       16
       +
       		return r.OwnerHandle

     

       17
       17
        
       	} else {

     

       18
       18
        
       		return r.OwnerDid

     

       19
       19
        
       	}

     

       20
       20
        
       }

     

       21
       21
        
       

     

       22
       22
        
       func (r RepoInfo) FullName() string {

     

       23
       23
       -
       	return path.Join(r.OwnerWithAt(), r.Name)

     

       23
       23
       +
       	return path.Join(r.owner(), r.Name)

     

       24
       24
        
       }

     

       25
       25
        
       

     

       26
       26
       -
       func (r RepoInfo) OwnerWithoutAt() string {

     

       27
       27
       -
       	if after, ok := strings.CutPrefix(r.OwnerWithAt(), "@"); ok {

     

       28
       28
       -
       		return after

     

       26
       26
       +
       func (r RepoInfo) ownerWithoutAt() string {

     

       27
       27
       +
       	if r.OwnerHandle != "" {

     

       28
       28
       +
       		return r.OwnerHandle

     

       29
       29
        
       	} else {

     

       30
       30
        
       		return userutil.FlattenDid(r.OwnerDid)

     

       31
       31
        
       	}

     

       32
       32
        
       }

     

       33
       33
        
       

     

       34
       34
        
       func (r RepoInfo) FullNameWithoutAt() string {

     

       35
       35
       -
       	return path.Join(r.OwnerWithoutAt(), r.Name)

     

       35
       35
       +
       	return path.Join(r.ownerWithoutAt(), r.Name)

     

       36
       36
        
       }

     

       37
       37
        
       

     

       38
       38
        
       func (r RepoInfo) GetTabs() [][]string {

     
···

       48
       48
        
       	}

     

       49
       49
        
       

     

       50
       50
        
       	return tabs

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

       53
       53
       +
       func (r RepoInfo) RepoAt() syntax.ATURI {

     

       54
       54
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.OwnerDid, tangled.RepoNSID, r.Rkey))

     

       51
       55
        
       }

     

       52
       56
        
       

     

       53
       57
        
       type RepoInfo struct {

     

       54
       54
       -
       	Name         string

     

       55
       55
       -
       	Rkey         string

     

       56
       56
       -
       	OwnerDid     string

     

       57
       57
       -
       	OwnerHandle  string

     

       58
       58
       -
       	Description  string

     

       59
       59
       -
       	Knot         string

     

       60
       60
       -
       	Spindle      string

     

       61
       61
       -
       	RepoAt       syntax.ATURI

     

       62
       62
       -
       	IsStarred    bool

     

       63
       63
       -
       	Stats        models.RepoStats

     

       64
       64
       -
       	Roles        RolesInRepo

     

       65
       65
       -
       	Source       *models.Repo

     

       66
       66
       -
       	SourceHandle string

     

       67
       67
       -
       	Ref          string

     

       68
       68
       -
       	DisableFork  bool

     

       69
       69
       -
       	CurrentDir   string

     

       58
       58
       +
       	Name        string

     

       59
       59
       +
       	Rkey        string

     

       60
       60
       +
       	OwnerDid    string

     

       61
       61
       +
       	OwnerHandle string

     

       62
       62
       +
       	Description string

     

       63
       63
       +
       	Website     string

     

       64
       64
       +
       	Topics      []string

     

       65
       65
       +
       	Knot        string

     

       66
       66
       +
       	Spindle     string

     

       67
       67
       +
       	IsStarred   bool

     

       68
       68
       +
       	Stats       models.RepoStats

     

       69
       69
       +
       	Roles       RolesInRepo

     

       70
       70
       +
       	Source      *models.Repo

     

       71
       71
       +
       	Ref         string

     

       72
       72
       +
       	CurrentDir  string

     

       70
       73
        
       }

     

       71
       74
        
       

     

       72
       75
        
       // each tab on a repo could have some metadata:

+82 -54

appview/pages/templates/fragments/dolly/logo.html

···

       1
       1
        
       {{ define "fragments/dolly/logo" }}

     

       2
       2
       -
       <svg

     

       3
       3
       -
          version="1.1"

     

       4
       4
       -
          id="svg1"

     

       5
       5
       -
          class="{{.}}"

     

       6
       6
       -
          width="25"

     

       7
       7
       -
          height="25"

     

       8
       8
       -
          viewBox="0 0 25 25"

     

       9
       9
       -
          sodipodi:docname="tangled_dolly_face_only.png"

     

       10
       10
       -
          xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       11
       11
       -
          xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       12
       12
       -
          xmlns:xlink="http://www.w3.org/1999/xlink"

     

       13
       13
       -
          xmlns="http://www.w3.org/2000/svg"

     

       14
       14
       -
          xmlns:svg="http://www.w3.org/2000/svg">

     

       15
       15
       -
         <title>Dolly</title>

     

       16
       16
       -
         <defs

     

       17
       17
       -
            id="defs1" />

     

       18
       18
       -
         <sodipodi:namedview

     

       19
       19
       -
            id="namedview1"

     

       20
       20
       -
            pagecolor="#ffffff"

     

       21
       21
       -
            bordercolor="#000000"

     

       22
       22
       -
            borderopacity="0.25"

     

       23
       23
       -
            inkscape:showpageshadow="2"

     

       24
       24
       -
            inkscape:pageopacity="0.0"

     

       25
       25
       -
            inkscape:pagecheckerboard="true"

     

       26
       26
       -
            inkscape:deskcolor="#d5d5d5">

     

       27
       27
       -
           <inkscape:page

     

       28
       28
       -
              x="0"

     

       29
       29
       -
              y="0"

     

       30
       30
       -
              width="25"

     

       31
       31
       -
              height="25"

     

       32
       32
       -
              id="page2"

     

       33
       33
       -
              margin="0"

     

       34
       34
       -
              bleed="0" />

     

       35
       35
       -
         </sodipodi:namedview>

     

       36
       36
       -
         <g

     

       37
       37
       -
            inkscape:groupmode="layer"

     

       38
       38
       -
            inkscape:label="Image"

     

       39
       39
       -
            id="g1">

     

       40
       40
       -
           <image

     

       41
       41
       -
              width="252.48"

     

       42
       42
       -
              height="248.96001"

     

       43
       43
       -
              preserveAspectRatio="none"

     

       44
       44
       -
              xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAxUAAAMKCAYAAADznWlEAAABg2lDQ1BJQ0MgcHJvZmlsZQAAKJF9&#10;kT1Iw0AcxV9TpVoqDmYQcchQneyiIo61CkWoEGqFVh1MLv2CJi1Jiouj4Fpw8GOx6uDirKuDqyAI&#10;foC4C06KLlLi/5JCixgPjvvx7t7j7h0gNCtMt3rigG7YZjqZkLK5VSn0in6EISKGsMKs2pwsp+A7&#10;vu4R4OtdjGf5n/tzDGh5iwEBiTjOaqZNvEE8s2nXOO8Ti6ykaMTnxBMmXZD4keuqx2+ciy4LPFM0&#10;M+l5YpFYKnax2sWsZOrE08RRTTcoX8h6rHHe4qxX6qx9T/7CSN5YWeY6zVEksYglyJCgoo4yKrCp&#10;rzIMUiykaT/h4x9x/TK5VHKVwcixgCp0KK4f/A9+d2sVpia9pEgC6H1xnI8xILQLtBqO833sOK0T&#10;IPgMXBkdf7UJzH6S3uho0SNgcBu4uO5o6h5wuQMMP9UUU3GlIE2hUADez+ibcsDQLRBe83pr7+P0&#10;AchQV6kb4OAQGC9S9rrPu/u6e/v3TLu/H4tGcrDFxPPTAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBI&#10;WXMAAC4jAAAuIwF4pT92AAAAB3RJTUUH6QkPFQ8jl/6e6wAAABl0RVh0Q29tbWVudABDcmVhdGVk&#10;IHdpdGggR0lNUFeBDhcAACAASURBVHic7N3nc5xXmqb564UjCXoripShvKNMqVSSynWXmZ6emd39&#10;NhH7R+6HjdiN6d3emZ7uru6ukqpKXUbeUKIMJZKitwBhzn64z1uZpEiJIAGkea9fRAZIgCCTQCLz&#10;3O95nueAJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJOkONYO+A5IkjYtSSgNM0Ht9LX036vvbj7fvX+77K/pfl0vTNAVJGgGGCkmS&#10;vkUNCjRNU+qvG2ASmKpvJ+rb9n3T9e0EvTCx3Pfr/o8ttf9M/fVS/bOL9bbU97HlvrcT7d/bNE1/&#10;KJGkgTBUSJI6ry8stIGhDQhTwAwJCu1CfhrYCGwGZoENwCZgS9/7pkgAmKuf0+5QTNbPnagfu9L3&#10;7zYkMCwA54BL9deQYHGlvm+eXkBZrH/P1fpnl+mFj4K7HZLWiaFCktQpNUDcuMMwScLCDFn0tyFh&#10;K7Ctvt1Q/9yG+vsd9WNbgO319zvrxxrgInCaLO6n6t87S4JHA5ytN/o+PkMCwTHgDHCNXrg5A5yq&#10;f+9ivf9X6/tPA5dJ8Gjftrsd1+qt3eX4S8gwcEhaLYYKSdLYakuXqnY3YANZ2LeBoD88bCMBof/X&#10;2+vHZ+kFjvbX01y/s9H+GrKIX7zh327DzK0+PkEW/m0IKH0fu0hCROn7d88DJ+pbyA7HMeAreuHi&#10;PAkdZ4EL9e9u+zkWgCXDhaS7ZaiQJI2VvmbpdvehDQJtydJOYD9wD7CL3i5DGyTaALGJBJAN9Pok&#10;2tsk6/8a2u40tOGkIQGhLX1q6IWIy/XPXwC+Bo4DX5LAcY5e6dU5ElYuk7KqtsfDXQxJK2KokCSN&#10;tBuap2folS5tIWFhL7CHXnnSXmAfsJvrdyA2kgAxQy84jJq2vKkNVldIaDhHSqdOkL6Mufq+L0jg&#10;OFk/3n5sjoSMhaZplpCk72CokCSNnL7diP6m6V0kPOyhFyT2kV2JvVzfAzFLr4ToxtfCcXttbMfW&#10;zpOdjXac7QWye3GclEsdIyVS50j4OFH/zEUSMtpGcJu/JX3DuD1xSpLG1E12JNogcS9wCHgBeIIE&#10;ie314+3kprbXYYLeORFdew3sPy8DeqNr5+ntZiyR4PEZ8A4JHZ+R0HGalFbN1c9bBsukJEXXnlAl&#10;SSOmlNI/inUrCQy7gfuAB+vtAeBx0ifR9kBM3Ozv000tcf342kv0+i2OkHDxFfAB8DHZxbhcP+ea&#10;Z2VIMlRIkoZO3ZWYoje+dScJD48CB+mVNe2rH2snNU0P4v6OsWWyQ3GJlEZ9BLxFgsbx+rGv6fVi&#10;LLhzIXWToUKSNDRKKW1p0yzpgdhHQsQDwHPAs6TcqT03Ygpfy9bLItm9+JTsXHxZf/0JCRhfkzMz&#10;2gP6Ft3BkLrDJ2JJ0sDccJL1NNlx2E9CxEP19gBwgISLvSR0tH0RWl9L9EbPXiFh4hgJGJ+TgPEp&#10;mSp1ht4hfDZ3S2POJ2RJ0kDUXon2JOk2TDwBvAQcJiGiHfnaP+rV167BakfWtk3d8/TKo06Sxu4/&#10;AG/XX5+h9l+4cyGNL5+YJUnrrpQyTQLDPWQn4kGyK/EE8BRpwt4ysDuolWpP527Pv/iEhIr3SbA4&#10;Shq9zwPz7lpI48dQIUlac7XMqb9fYjcZA3uY9Ek8SALGbrJr0ZY4afQsk7Knk/RO8X6LhIyP6/vb&#10;xu5FA4Y0HgwVkqQ10xcmNpEpTfvJLsTDwNPA88Aj5EyJ5oabRld74N4SCQ/tzsV7JFgcITsXZ4Gr&#10;wJKlUdJo80lbkrTq+sLEBjLq9SHge8CL9HYldtWPbcLXo3FWSN/FGTKC9jTZufgDKY9qT/K+gjsX&#10;0sjySVyStOpKKRtJaLiPnC3xPAkUT5Eg0Z507etQdyyRSVDXyOF5H5JQ8RE5VO8jUhp11V0LafT4&#10;ZC5JWhV1mtMMabC+D3iG7E48QfonDpKzJ3zt0TJp2j5F+i7eB34PvElG057DcCGNFJ/YJUl3rO+c&#10;iRmyA7GflDo9B7xMQsUeeqNgfd1Rq9CbGnUKeAf4d64vi7qAo2ilkeCTuyTpjtRAMUWarO8lOxOv&#10;0pvmtJeMjfVsCX2bQkqjLpPm7feBN8jOxUfkpO7L2G8hDbWpQd8BSdLoqYFihkx0epT0S7xCeicO&#10;kKAxhWNh9d3acLqNHIS4k4TUg8C79HovTpZSrjRNszSoOyrp1rxyJEm6bTVMbCS9EfeQ0bAvklKn&#10;J8nuxMaB3UGNg/aci6/ILsUR4DXSb/EJmSI1Z0mUNFwMFZKk79RX6rSVNGE/ScqdHqu/PkR6KtyZ&#10;0GppdyTOkhG0v6+3d0i/xWXst5CGhqFCknRLfY3YG8iI2MfIrsSPSTP2TrIzMY2BQmtjmRyQ9yXw&#10;R+B10sz9MWnwvmpJlDR4hgpJ0k3VQDHN9Y3YPyHlTg+TUqfpgd1Bdc08OTjvE3o7F38CjpIRtDZy&#10;SwNko7akNdN3lfu6d/e/8NezDdo/U/o/3vf5xcXC+qpf+00kTDwCPE3vROwHgFl8DdH62kD6eLYA&#10;+8hAgP0kXLxHGrmv+lwhDYYvCJJWpC424fqwMFFvk/VtU99Ok+eZ6fqxkr+iLJOSBur72ylBi8By&#10;/Xg7w576vkUyz779WPu2v+yhDSXWWN+FUko7iecBUur0A+Dx+vv92IitwZkkj81NpIdnNwkYu4E/&#10;A1+UUi42TbM4uLsodZOhQtI33BAc2sDQkBf0NgRM9n18hrzIz5KridP17eb6vtn68Wv0QkAbCKbq&#10;xydJ3fRC/fhy/fgyKXu4TCbCtMFiAZirn7NE30FapZQ5vhlArgsqXs38prprNE0Oq3uCnDnxH8m5&#10;E1vpPRakQZsiQWKW9PrsI+V4vwc+KqWcIU3c/pxL68RQIQm4rgypf9ehDQdtYNhSb9vq23aHoR0x&#10;urN+bCu5irij/rnZ+nefJiGgrdVvw8gmEgxu9vENwEXgJJkCU+q/t1h/f4IEDurnzdU/ewq4VH9/&#10;pb69Vj9voe58XFdu1WWllEkSAg8CLwH/AXiB7E5swzCh4dJe5NhMTnDfSkLFPaSR+23gy1LKnE3c&#10;0vowVEgdVnckJsnivQ0Ms+SFenP9/VayqNxOLyhsp3dQVbvwn62/33DDrS19gixY252IdrejnRpU&#10;6sfbsoV2R2SKhIHLZMeC+jntCbyX6ue0i97LZLZ9GygukvGTbWCZI2HkNGnuvFJKuVY/d4k0e3aq&#10;fKqUMk0C4ZMkUPyI9E60pU4O9dCwaieT7adXErWX7Fz8O3C0lHK+aZqFW/8VklaDLxTSmOtrdm4D&#10;xBTXL/pnyYLyHvJCvIteeGh3HbbSK2VqdxbaQNH2Taz380lb1gS98izolUq1pU6XyW7GhfqxK8Dx&#10;+r4v6q8vkkBxBThff9+WUC3B+JZLlVJmSLnTU8AvSaB4gjwmZvB1QqOj0Bs9+zbwW+B35ETuk3hg&#10;nrSmfLGQxlANEm0J0wwJABtJMGibG/vDQztJZS+90qY2QGyof0fbQwHXP3cM4/NI6Xvbho/2frY7&#10;FZfJ4uMYCRILZPfiS3KS74n6566SnZB5ej0hy6MeMmq520byPX8K+Cvgb0ig2MJwfl+l71LIz+sZ&#10;4CMSKl4nI2i/AC7ZxC2tDV80pDHRtyPRNk7PksCwh4SG9nYvCRB7SKhodyH6DzDrv91sLOwoaxvE&#10;l0nAmO/72CkSJr4GPiMBoy2TOlE/fp56km/9e0auJ6P2T8ySWvQXyISn75Pyp+2M1/db3bRIdh6P&#10;kbMsXiNN3B8A5yyHklafPRXSCOsLEu2OxGZ6k1AeIVegHyE7EzeWMLU7EG1vQ1c09J77psnXpV1E&#10;byd9HXPkSudFsji5BBwBPidXO4+RwHEGuFxKmWdEDt7q6594GHgF+CkJFnvJ48NAoXEwRX62D5Gd&#10;t930SvreK6Wcbprm2q0/XdJKGSqkEVTDRNsb0TZS7yY7EA/U26PkbIEDJEQ4veebblxAz9TbNrIA&#10;WSaBa5GUBZ2h14vRhotPSNg4U0q5Sp0wNWy1233lTveQg+xeJedPPEMeIz4+NG7aAxzb58B2R3Yr&#10;8FYp5SvSZzH0FwOkUeAVKWkE3GRHoi1tupdciTtQf32QXmnTTvLiabPt6mgXHnOk6fsCKZN6lxy6&#10;9TEplTpNr2djKEqk+sqdHgCeB35MGrIfII+R6UHdN2mdLJOfyY9JA/c/k3KoY8BVx85Kd8+FhjTE&#10;+hqu2/McttNrqn6IHEr2Arn6vIleQ3X/ydb+nK+u/sP0FkiA+Aw4SibMfFJvX9LrwfjLJKn1Dhd1&#10;h2Iz8CBpxv5r4DngPhI03KFQVxSyk3iCNHD/f8BvyM/vJYOFdHdcbEhDqq/EaTuZwf4g2ZV4CLif&#10;3q6EZwkM1iK9A/baxtCvyKjaj4FPyaLlK9LwfXW9SqPqY6htyP4x8F9IQ/ZuUjrnY0Zd1E56e4sE&#10;i38kY2cvDlvZojRK7KmQhki9qjxJr+53H+mNeIHUvt9DFoTbyNXn9nA5F4eDM0Xv4MBCSs8eI83d&#10;X5Hdig9JidSH5JTfc9RRtWu1c1EfS9tIoHiZ3gnZ++lWY750o2nyXDpJLgjMkefQT0op5xw5K90Z&#10;FyLSEKgLwHZayV7SH3E/mdDzNClXeYiUN2k0LJNxtcskXLxDr/fiU7Kj8TW192I1r5DWHortZETs&#10;j0jZ0/NkIbVhtf4dacRdI2WKfyJlUK8D7wGnHTkrrZw7FdKA1NKU9oTrTWQUbHtuwGFS7rSf3jhY&#10;m2lHSzttCfJ93UPG+54g42nfrrejwNlSyhVWoe+ilDJFdigeB34O/C0JpZtxh0LqN01KSGfJYItt&#10;9X1vllJOMyJjoqVhYaiQBqBvvGfbeH0/WXA+Q64oHyIvdG3jddt0rdHSfs8myYJlI5m49Dj5Xr9D&#10;pkcdIbsXx4HzpZT5le5c9PXg7Kh//09IqHiahFIbsqXrNeQ5djcZejFbb9NkV/FkKWXBYCHdHkOF&#10;tE5umOS0g5Q2PUcWfYdIaco+ckV782DupdZQGyQ3ku/vNlLmdpiUYLxHyjCOAMfbvovbCRf1sTVN&#10;FkfPAD8jB9s9TR5rBgrp1tpywSfIrvEW8vP5W+BYKeWawUL6boYKaR307UzsJAvJtvn6ZXJVeTcJ&#10;Gy7+umGC3gnnB0jvw+PkcfEOKYn6EPi4hotr3xEupkj53GHgF6Qp+xBZKFnyJH239mfycXqlgov1&#10;drLuHhospG9hqJDWUA0T0+TK173kyvHzZPH3MFlQbsOfxS5qe2r6DzTcT66WniTlF78h5VEnSymX&#10;uEm4KKVMk0DxDDmDoi152oQlc9JKTZNy1JfJBLdrZAfxZCnF07elb+FCRloDffXt7VjYh0mYeJUs&#10;/vaRheQ07k6oV9vdnoL+KHnMPEom0vwJ+Ag4UUq5TG3mrk3Ze8jZE39F+iiexHNLpLsxSe+wyIl6&#10;+3fS83RtgPdLGmqGCmmV1YXeZrIz8QxZ8D1Hrn4dIDXu/uzpZtqdiw2koXsrecw8AbxBdi+OAudK&#10;KddIedOzwP9CRsceIrtiBlXp7syS4RnT9bYM/K6UctKTt6Wbc2EjrZJa6tRebX6YhImXSe/EIVKO&#10;4mJPt2uanFmylTTxt2eXvAd8AVwkO14/JldUH6Y3wlbS3ZkgAf0hMur5HHAFWC6lnPEcC+mbDBXS&#10;Xeprwm4PrmsDxU/Jycq7sRxFd6YhYfQg2f06SMrovgDOkF6K50mphofaSatvhoT5H5JwAfUcC0/e&#10;lq5nqJDuUN+I2M3AfcBTpEzlyfrrR+mdD2Cg0N2YJGVzW8mu18V6a6c+2ZQtrY123Oxz5OLQNJkI&#10;9edSyrmVnicjjTNDhXTnZsiC7lFS5tS/M7EFy520uvonRW0kjz3I87iPM2ntTJJA/xT5WbsIXAU+&#10;KKVcsMdCCkOFtAJ9h4y1jdiHySFj3ycvOHtwgae11wYMSeuj7bF4hExZu1Lfb7CQKkOFdJtKKZNk&#10;Isg+0rz3FPADEijurx8zUEjS+NpMJq4tk2DfAO/VYGEplDrNUCF9h7o70W5/Pwi8SHYnnqi/30fK&#10;UQwUkjTepslz/sv0hiNcIefIXLnVJ0ldYKiQvkVfudNuEiJ+RMZ3HibNe+0BdjbJSlI3TJHBCU8C&#10;F4BTwOVSyhdN08wP9J5JA2SokG6hjoqdJWM8XwR+BrxEpu/sxCAhSV01SS42PUuCxWkSLE5aBqWu&#10;MlRIN6i7E1MkOLSTnX5U396PZU6SpJQ/3Uv66r4AzgLzpZTzBgt1kaFC6lMDxQy5AvUM8HPgF/R2&#10;JwwUkqTWRuAA8Cq9U7ffLaXMGSzUNYYKqeo7GXsP8DQJFD8nU548c0KSdKMJYBvwAnCJlEGdBb6q&#10;waIM8s5J68lQIfVsITsSz5PeiVfIYXabsX9CknRz7anbT5Ay2XPAEnAcsHFbnWGoUOeVUqbJlaZH&#10;SJD4KdmpuI+MkTVQSJK+zSQpg3qFBIpFYKGUcsKD8dQVhgp1Vi132gDsJSVOLwM/JNvYe8ioWEmS&#10;bsdWslsxTXYoLpCJUBcsg1IXGCrUSTVQbCa7ES+SsydeJidlbyZXnSRJWolN5FDUHwFfkTMsPiyl&#10;XDNYaNwZKtQ5NVBsAR4mT/y/IIfZHajvt9xJknSnNpELVD8j/RXnSX/FwgDvk7TmDBXqlL4dikOk&#10;1OlvgB+QEbIzGCgkSXdngowgfx44CXxKyqDO21+hcWaoUGeUUiZJzesh0kz3MzLl6R78WZAkrY6G&#10;9FXcA3wP+Bw4A3xQSrloGZTGlQspdUINFNvIiNi/An5MriLtx58DSdLqmwQeBf4D8CUphZoDrg3y&#10;TklrxcWUxl49JbudyvFz4H8l4WI7/gxIktZGQ8ptHyQXsT4CzpRSzrpboXHkgkpjrZ5B0R5K9FPg&#10;l+QMih2DvF+SpM7YBjwJPAOcAK562rbGkaFCY6uUMkPOmzhMpjz9BHiO7FpIkrQeNtA7XPUUmQb1&#10;JTkgTxobhgqNnVruNE0mOh0G/hMJFI+SkbETg7t3kqSOmSb9ez8gDdsngIt1GtTyQO+ZtIoMFRor&#10;NVBMkUDxDJnw9FPSQ7GV1Lg6NlaStJ6mgH1kGtRxEizmgSuDvFPSajJUaNxMAXvJE/dfk7KnR0ig&#10;cIdCkjQIbdP2E2S34h3gRO2tcLdCY8FFlsZGKWWKNGA/Sw61+1vgKdIk52NdkjRIk8AucqHrCbJz&#10;sWGg90haRS60NBbqORTtlKefAb8g/RQ7yRO5JEmD1pDXpadJWe7uekFMGnk+kDXySikTXB8ofkmu&#10;BBmaJUnDZhuZRPglKYW6VJu2HTGrkWao0EirjdmbSYhoz6F4BNg0yPslSdItbCQH4r1MGrZPk7Mr&#10;rhksNMq8kquRVXcoZoEHgJfI2NinyVUgJzxJkobRBBlv/jg5u+KZ+ntftzTSDBUaSX2B4hB5Uv4J&#10;eWLegTtwkqThNkFGnz8LvECatqcHeo+ku2So0MipJU8bgAMkTPxn4FXgHnxSliQNvwaYIa9jT5Gy&#10;3c31gpk0knzwahRN0ztE6JekLvU+Uqfq9rEkaRS0PYEPkxLe+4FN9cKZNHIMFRopdfTebjI54+fA&#10;94F7yRUfH8+SpFEyCRwEfgg8SSYZ+lqmkeQDVyOj7yyKx8lJ2T8mT8aWPEmSRlFDegGfJGcrtRfJ&#10;pJFjqNBIqHWmW0jd6avkqs4j+OQrSRptEyRYPA08Cuy0t0KjyAetRsVGMjr2x6SP4jBp1rb2VJI0&#10;6jaQXfiXyAWzjfZWaNQYKjT0SikzZLLT90ioeJpc1fHxK0kaB9PkwtnLZMysvRUaOT5gNdTqFvBO&#10;MnLvVbJDsYc0t0mSNA76S3yfAPbimUsaMYYKDa0aKNpxez8AXsQmNknSeGqAbWRE+n1kvKzrNI0M&#10;H6waSrWWdIZMd/oeCRUPk5Bhnakkadw0pH/wAPAYGZ/udEONDEOFhlV7HsVhUmP6NKkxtexJkjSu&#10;pkioeJ5cSNtiw7ZGhaFCQ6du924lV2peIU+u+/GKjSRpvDWkn+I54Blycc3eCo0EQ4WG0SbgfjJa&#10;7yXgUH2fV2skSeNuE5kE9TS5oLZhsHdHuj2GCg2VUso0GR/7HDng7gnSuCZJUldsIMHifmCrJVAa&#10;BYYKDY0bxsf+iASLXfg4lSR1Szuo5DFq+a/BQsPOxZqGQg0UW4BHSWO242MlSV01DewjPYXtjr1r&#10;Ng01H6AaFu1VmRfJ+NhHsI9CktRNE2Ti4bP15mF4GnqGCg1cKWUS2AE8SQLFU+TJ1MenJKmL2rOa&#10;7iMlUPfjYXgacj44NVC1RnSW7FK8QM6luAfPo5AkdVsbLO4lUxC34WujhpihQoM2RbZ1D5PSp/vJ&#10;iaKWPUmSuq4hZ1U8RF4r7TPU0DJUaGDqNu42es3ZbdmTgUKSpNhGLrgdICVQvkZqKBkqNBD1SXGG&#10;PEm+QELFAbwKI0lSvy0kVDxC+g8tgdJQMlRoUCbJ1ZengVfIboWnhkqSdL3NpPzpJdJ/6GulhpKh&#10;QoMyRU4LfZkccrcVH4+SJN1oivRVPE6atmctgdIwchGnddc3QvZRMipvDz4WJUm6lQ2kUXs/XoTT&#10;kPJBqXVVr65sIePxnsU+CkmSvsskee28l+xazLhboWFjqNB6mwb2Ac+T+tBDeHK2JEnfZRPwIOmr&#10;2Iyvmxoyhgqtm75digfJxKfHcYSsJEm3Y5LsVNwP7MQpUBoyhgqtixoopslp2YeB75H60KlB3i9J&#10;kkbEJNnpf5C8lk5bAqVhYqjQepkgzdlPAT8g87Y3DfQeSZI0OibJYJPHgYexdFhDxlChNdd30N1B&#10;0kfxIjmjwsefJEm3p70490y9bcUSKA0RF3VaDw0wSw7veZyMxLPsSZKklZkk058OArtIWbE0FAwV&#10;Wg8zpP7zCdJg5patJEkr15DX0D31tsG+Cg0LQ4XWVCllgmzRPkK2a+8luxQ+CUqStHIzZHLiHnIo&#10;nms5DQUfiFpr02TK0zPAk+RJ0BpQSZLu3Bby2jqLazkNCR+IWmubyKnZT9a3TnySJOnubCavqdux&#10;R1FDwlChNVNKmSYNZYdIL8Xmgd4hSZLGwyZSTryTlENJA2eo0JqovRTbSC/F8+Swno0DvVOSJI2H&#10;jaT8aQdOgNKQcMtMq6ZOoGjI42ozCRQ/IGdT3ItXUyRJWg0zJFBsx9dWDQlDhe5aDROT5PE0S7Zj&#10;7yeB4qfkbAp3KSRJWh1TJFDsBGZLKRNN0ywP+D6p4wwVumN9YWIjKXXaQw64O0zOpHiM9FN4erYk&#10;Satnioxr308OwTtWSplrmqYM9m6pywwVWrFSyiTZbt1CGrHvBe4juxNP0juPYhuZoe3jTJKk1TNB&#10;bwJUO1p2HjBUaGBc7Ok79fVKtLsSO0iIeKjeHgAOklOz9wP7SOOYB9xJkrQ2ZuidrD0LnBvs3VHX&#10;GSp0SzVMTJAnrk1k52E/KWt6md5Up60kbEyR4NGGEEmStDYmyOvvdvIa7euuBspQoZuqgWKKlDjt&#10;J70RD5OJTo/V236y/doGCUmStD4myGv0DurJ2qWUxr4KDYqhQn/RFyQ2kKsfe0mQeL7eHqA3wm5L&#10;/XOGCUmS1l/bV7GjvnUgigbKUKH+KU5bSD/E/fV2iOxIPEPCxdYB3UVJknS9NlRsr2+ngGvYrK0B&#10;MVR02A07EztIf8Tz5LC6h+mNqmt3JSRJ0nBo6A1PaQ/BuzrQe6ROM1R0UA0TkKCwi0xyehx4gQSK&#10;J0lT9mS9TWCZkyRJw6Qhr+O7yfTFHcCVUsqyfRUaBENFx/SdMbGNlDi9ALxCgsQB8uS0FWszJUka&#10;Zg15Pb+HHDh7hJQ/nSqlzBsstN4MFR1RSpmgtzPxAPAo8DQpd3qWPClND+wOSpKklZogQ1WeJ6VP&#10;20m4OFlKOV/ft9A0zfLg7qK6wpKWDiilTJO+iHtJkHgZeI4cXLe3fmwKHw+SJI2aBXLw3RfARyRU&#10;fAwcrbfTwJX65yyN0ppxETmm+g6umyZ1lo8A3wd+SEqeDpIGLw+rkyRpdJV6uwZcIgHjaxIwfge8&#10;QwLH2frxeQwXWgMuJMdQLXXaSEqdDpBA8T2yQ/F4ff8Mfv8lSRony8AiCRjngE+Bd8nOxcfAh8CX&#10;9WPXgGK40GpxUTlG+kbEbiPjYZ8jdZaPkDMn7if1ln7fJUkab0ukp+IU2aX4DPgT8DbwCXAcaPsu&#10;Fg0XulsuLsdEneq0AdhDDqx7CXiVhIo9ZOfCvglJkrqjPyhcIGHiPdJrcQT4gJRGnSF9F4s2detO&#10;ucAccXV3om3E3k8asX8M/IAcYLe7ftzvtSRJ3dX2XZwjAeIY8Md6a8uiTpO+C3cutGIuNEdYDRQb&#10;yVSnJ4DDpAn7BVL+tIFeI7YkSdIS6b2YI6VRR+rtfVIa9X59/xw2dGsFXGyOqFLKFOmPeAj4Edmd&#10;eITsVuwmYUOSJOlWFoGL9XaMTIr6HfAm6cE4A8xZEqXbYagYMX2H2O0jOxM/AP6K7E5sIzsTkiRJ&#10;KzEPnCA9F38kTd3vAZ+TfgwP0dO3MlSMiFrqNEl6Jw6SBuy/AV4kJ2RvxUAhSZLu3BJwmfRXvAf8&#10;HniDNHZ/TfotDBe6KUPFCOgbFbud9E68QkqeXgTuIaVOEwO7g5IkaVws0zul+yjwZ9Jz8SbptzhJ&#10;xtAu2W+hfoaKEVD7J3aTcqdfAj8lY2N34mQnSZK0+tpdizOk/OlN4DVSFvUJmRQ1766FWlODvgO6&#10;tbpDsZnsRjxBmrF/ATxDyqAkSZLWwiTp1dxKxtHuBQ6Qw3R/R5q6vyylXCQlUe5adJyhYgj19U9s&#10;JtOdvkdKda4xXAAAIABJREFUnl4g4cJAIUmS1kNTb/eSkHEvCRcHSWnUx8DXpZQrTdMsDexeauAs&#10;mxkyNVDMADvI4XWvkOlO36c3KtaGbEmStN7aA/TO0Ou3+C2ZFvUZcB4PzussdyqGSB0Xu5HeuNgf&#10;Ay+R3Yl7sH9CkiQNTkPG2u8l1RR7yM7FflIS9T5wspQyb7DoHkPFkKiBYpachP094IfAq/X3W8nu&#10;hSRJ0qBNkVKojaQkexcJGntIQ/fnpZSLNnF3i6FiCNSSpzZQ/IQ0Yz9Hzp+YHeBdkyRJupUZUl2x&#10;hUykbIPFG8CRUspZbOLuDEPFgPUFigfI2RP/iexS7MLvjyRJGm7tYJlHyXla++rtdTIh6kQpZQ5Y&#10;NlyMNxetA1RLnraRCU+vkh2KF0nKtxlbkiSNggnSa7Ef2EQujN5DwsUfSVP3xVKKTdxjzFAxIDVQ&#10;7ACeJIfZ/Qx4mvwQGigkSdKomSJlUBtIP+geEix+D3wAnCqlXDVYjCdDxTrrO4NiG/A4CRR/Czxf&#10;32egkCRJo2qC9FgcIsGibeLeBbwNfFFKueSZFuPHULGOaqCYJjWHj5Meip+R8bHbMVBIkqTx0DZx&#10;z5JztvaRnYvfkSbuC8CSuxbjw1CxvibJtuAzpH/iVVL+tBMDhSRJGi+TZLfiYXLxdDepypgBPgTO&#10;AgsDu3daVYaKdVJKmSRbf4dJoPhb0qC9Fb8PkiRpPLXncE2TXotNZO3zb8CbpZSTwDV3LEafi9l1&#10;UEqZJlt+zwB/TULFk2QEmyRJ0rhr10IvkN2KXWQd9Afgy1LKnIfljTZDxRorpUyRH5zvA39FDrd7&#10;miR1SZKkrmgnXz5T326ut98Cn5VSrhgsRpehYg3VkqcdJET8FxIqHiSBYmKAd02SJGlQZoD7gL8h&#10;66RZ4J9JsLhssBhNhoo1UgPFdlLm9AtySvYh8oPTDO6eSZIkDVRDgsVe4FngMmnYngGOllIuOHJ2&#10;9Bgq1kA92G4rGRv7E7JDcQgDhSRJUmuSjJr9PgkU24DXgPdLKWcNFqPFULHKaqCYJWVOr5DG7KdI&#10;yDBQSJIk9bRrpi0kVGwiYeOdUsq5pmkWB3nndPsMFauoHm63CThIUvdPgOfwHApJkqRbaUuhXiTr&#10;qHYE7dullDPAgiNnh5+hYpXUQLGRBIq25Ok58kPi11mSJOnWpkgv6nOkumMnmQz1BnCilOLp20PO&#10;xe7qmQbuJadk/2+k8Wh/fb8kSZK+XXsC9+Nk92IOmAeWgdOlFHcshpihYhXUw+32kW27/0CCxV4c&#10;GytJkrRSG0mfxY+Aq/V9b5Jg4enbQ8pQcZfq4XY7yc7EL8gPwE4MFJIkSXdqA/AEUOitV/8EnCbj&#10;ZzVkDBV3oZ5FsRV4FPgx8DJwAEueJEmS7kY7nv8ZEjCmSCnUm3UqlONmh4yh4g7VxuwtwMMkUPwQ&#10;eIhs2Tk6VpIk6e5MkLXWIeAl4BRwjd45Fp68PUQMFXfghklPLwE/JWdRbMdAIUmStJo2A4+RnQpI&#10;2Hi7lHLeYDE8DBV3ZgrYQ7bkfkTGn+3BsygkSZJW2zRZZ71ISqEgAeO9Usplg8VwMFSsUF8fxWOk&#10;h+J7ZPKTfRSSJElroz3H4gVSAnWJjJw9arAYDoaKFahlTxvImLMf1NuD9FKzJEmS1sYk6bF4EjhP&#10;pkBNAJ+UUi4ZLAbLULEy0+RAuxeAV8jhLFtwfKwkSdJ6aEgp1PdJyJis7/uI7F5oQAwVt6mWPe0E&#10;niaTng6TB7WBQpIkaf1sIMNy2kqRq8DlUsqngKduD4ih4jbUsqetwCNkh+JF4F7so5AkSRqEKWAX&#10;OXz4DHCO7FR8DSwO8H51lqHiO/T1UdxHttpeJvOSZwd4tyRJkrquLUt/GbhAAsXVUsoF+yvWn6Hi&#10;u02R6U6HyYP2SWAblj1JkiQNUgNsAu4nVSTHyG7Fh8DFAd6vTjJUfIvaR7GNNGS/DDxPAoZfN0mS&#10;pMFryOF4j5LDiM8Bl0op14Br9lesHxfHt1DLnmbJyNiXSOnTg8AMnpotSZI0LCaAvWS34hRwErgM&#10;fF1KsXF7nRgqbm2aPECfJ83Zj+H4WEmSpGHTkDXtTuA50lsxB/yJhAwbt9eBoeIm+qY9PUzKnp4G&#10;dmOgkCRJGlYbyaTOJRI0loA3Sinnbdxee4aKG9RAsRE4QNLuC2R87Mwg75ckSZK+1QSwg1wMXqY3&#10;YvZD4MoA71cnGCq+aZLMPX6K9FEcwvGxkiRJo2ILKVs/B3wBXCilfNE0zcJg79Z4M1T0KaVMkNFk&#10;7SF33yf1eZODvF+SJElaka1kx+JvSV/FpVLKacug1o6h4nrtmRQvkEBxP5Y9SZIkjZppsqZ7ETgC&#10;nCAH410xWKwNQ0VVdym2kbKnV4EnsOxJkiRpFPX3yP6U7FZcAI6WUuYcM7v6DBU9MyTRPkdOz947&#10;2LsjSZKku7SRrO1OAp8BZ4EFHDO76hyRynW7FA+Sfood2EchSZI06iZIf8Uj5KLxvcDGOu1Tq6jz&#10;OxV9I2TvI3V3z5BQIUkajP6yBF/4Jd2tBrgHeBb4mEyFulZvWiWdDxUkwe7m+hGymwZ5hySpwwq9&#10;0oRJUppqsJB0t3aQC8enydkVToNaZZ0OFX0jZB8Aniejx3bQ8a+LJA3QIjmw6gyZ3rKH7CZbkirp&#10;brRVKS+RsytOk2lQl23aXh1dXzxPkReswyRU3EtexCRJ668A88CXwLskSDxOprdsIc/P47RrUfre&#10;2uMorb2N5LiAHwFfkR2LOWzaXhWdDRV1l2KWnLj4Ehkhuxmf2CV9t1Jvy2SRO8F4LXYHZYFcPfx3&#10;4N/IC/3npN/tEWAXKYcah+fpQv5/banXRsYvNEnDZhLYTi4kfwy8B5wspSy5W3H3OhsquP6gu+eA&#10;/bi9Lun2LANXgctkgTtLSinHYbE7KIV8Tb8A3gBeJ1/fz8koyJdIieoB8vUe5efrZbIjc4b8f78g&#10;YeIZcqHLx5G0dqZJL+2j9XaUhHubtu9SJ0NFnfi0GTgIPElepDYM9E5JGhUFuEIWu0fJ4vYgGUk9&#10;6ovdQVomB1O1Vw8/r78/V29fk8OrnicDNbYzmk3ciyQ8nSAlXm8Ab5MSjJeAvyHhaSs+lqS1MknK&#10;oJ4nZ1dcLaWcbZpmabB3a7R1MlSQlLqLJNQHSK2uJN2Oa2RB2F5Nb8hu5wS9YDFqC91hsECCwxFS&#10;63ylaZrFUsoZsuA+R3YsvgZ+QK7o76G3QzTMX/O2XG4BuEh2Jv4MvAb8DviEBI236q//K3lM7SMX&#10;vIb5/yaNognSR/t94Di1aZvsjuoOdS5U1F2KTWQCwAskWGwd6J2SNCqWyGms7wK/An5d3/c1WfzN&#10;kheqUbyCPkhLJDQcBT4g4eEaQNM0y6WUdmfoEtmtOA68SoZsHCQ7z1Pk6uMwfd37w8Q8eex8QsLo&#10;v5EQcaJ+bJmEjf9Gdmv+K/Az4CHs95PWwjZyceKHZDjE2VLKnLsVd65zoYK84Owk51K8COzFLWZJ&#10;362Qq1gfkUXhG2Shu1g/Nkt2Pb9PDlkal4bitbZMvq5HSIP2e8DF/tnx9ddzpZR2Uku7a/EFKRW6&#10;jzyXb+f68bODChhtmFgkpXKnyH39gOxQ/IH8f880TbPQ93mLpZS2Uf08CSD/kTymduNrlbSaGnKM&#10;wNNkd/RTcoHoyiDv1CjrVKiouxQz5AX/EeylkHR7Fkl9/4dkd+I18gJ0hSyKj5GgMU0Wvd8j9bqz&#10;GCy+TSFfr2NkId0Gtfmb/eFaDnWufs4FeqNnHwEerreDZKEwQ17j1rM0qg0S10hQOkv+bx8B79fb&#10;kXq/L93s0K06geZyKeVNsjNztt5eJeFpZu3/G1JntGvCF8hz0Ed1t8ID8e5Ap0IFeXHZQbaTD2Ht&#10;s6TvtkCm9LxPSlZ+RRayF9tt8lqe8ykp47lIrjK/Sp5nttK959rb1X5t3wR+S3YpzpOgdlN10X21&#10;lPJl/dwjZHrfIXLF8en66z3ka7+JXDxqy6NgdZ73+8+YaMcLz9PbRTlGypg+IKHic+opvsC171q0&#10;NE1TSimfkjrvs/Xz/rr+37wYJq2OhqwFHyDPHW8B50opVw0WK9eZF7q6S7GBXOk5TA5U2obbyZJu&#10;rpCQcIZM5/lHskvxPmnq+8thSXUBeJUEi/bq8nlSE/8YuZjhc831lkkA+wj4DSkLOgEs3s68+KZp&#10;lmqYmyPfo8/JTtKfSK9cu2uxj5QObSe9CTNc33uxkp2M/gCxTB4D82Rn4gp5XBwlofNtEiiOkcfE&#10;Ink8ldudh1//j6fIztil+m/8ov7/NuIumLQaJsh68Fny/P4l8FUp5ZpnV6xMZ0IFedBsJYfcPUtS&#10;qadnS7qZNlCcA94hgeIfyQL4LLBw44tNbSieJ1ep/51cYZ4nV+OfIRPnFO2ZFJ+TsrHf11/Pr+RF&#10;vP7ZJWCplLJASo7aUa27yA7G/fV2oN7uIa8F0yRc9JdJQe8ww/b3y/XfaEPEAgkyV+jtSnxFmse/&#10;rP+PY2RX4jxwV6UUTdMs1AlYf6TX7P0fyVVVL4xJd68hIf0Z8vP7PvnZXqC3I6nb0KVQ0R528jAJ&#10;FNuw9EnSzbXjTd8G/oWUPL0PnGuaZvFWn1QXuQu12fYteiduT5KLGVvweQeyOD9OFsqvkTKhi3e5&#10;+F4CrpRS2p2LL0hp1HZSCrWPhIr95LVgK/l+bKIXKqbJ4mKWhI1FejsEcyQInSf9HOfJzsQxEmTO&#10;kZ2Xi/XPLaxW+UTtJTlLdnPmSHiaI2Nnd2GwkO7WJHmeeIIM8jlKfu49EG8FOhEq+g67u4+Eit24&#10;bSzpm9pJRMdInf+vSa3/B3xHoOhXy1baXY4pUno5Qw7b3Ey3g0U7lvcdEijeIlOQbutr+13qQr7d&#10;VZirV/k/J1/3reSCUntry6GmSKDYRAJFe4jhHAkP7eKi/f0FEjYukjBxZa3rr2tgvVhKeYfsWEzU&#10;+/4sCU5dfkxJq2GSXHRoy6DO1QPx3K24TZ0IFeSJdw95QX+U1DdLUqud2nOe3sjYfyU7FV+RBeRK&#10;Z5e3J0S/S2+87CR5DurquQPtFK33SaB4g3x9bzrtaTX07R61YeAEee1r6PVHTJFA0R6kt0QvRCyQ&#10;71u7m7HYd1sCltZz0dE0zdVSylHgf5LXslny2ubgEenu7SKh4hPqlDbcrbhtYx8q+nYpHiSzvg/V&#10;30sSZFE5R8px3iSB4nek6fdU/djySheOtXl7kd50o/7a/MdI6U2XgsUC+Xq+A/wTCW2fkJ6DNV+U&#10;13+jANdq/wX9/25ttG+4PmyU+n1s3/+XP37j56+zy2T37P+lF3iexj5B6W5toXcg3pukjNJQcZvG&#10;PlSQF4Lt5OrgUySFdumFXNLNtScdX6B3TsJr5GCyT+v7V9Q4fKO6IG0X02/Vd28ki7/H6q+7cHV5&#10;gV4PxT+T4PYhcH4Qp9fe7Hv6bfejL5AMhfq4ukQWPW153XZS4tuF13VprbSToB4mF6PfLKVctATq&#10;9oz1k0+9ujRNGvQepnfKraS1116Zv3GazjBYJLXwJ8jV8nfI7sTbZMv7MqtU1lL/jmt1NOjb9Gr2&#10;p8jQiHE+IK8Nbl+TUa//QHYoPiWBYlX6KLqoPq7OlVL+TMq2tpFzLO7DcyykuzFFem8fIuvGk46X&#10;vT1jHSqqzWTix/306mUlra1r9CbktFd+trD+Jxy3+seBXiElSR+RMPEOKSU5ShqI59eo6XaRTAv6&#10;I7m4sQS8TK6GbSMXQMZp16ItK/uaXFH/J3J44EfU0DawezZezpNdtkJ+tn5OXu98rZPuzAR5vXqE&#10;XJD+nBvOJtLNjXuoaBczB8ghSF2rYZYGoS11+RNZrG+gd4r9XjKBZ4Ze/fpaLqTbBuzLpATpc7Ko&#10;fY+MMf2C3nkCl7nNg9fuRC1ZuUZ2R35LJgedAH5ESjP3kq/VOASLZRLeviTlZL8i/+cjwKVBlDyN&#10;qzpu9hT5Ou8m02t20d1hANLdashF6CeA56kjr0sp6zqUYRSNbaiopU8bydbVfeTJdmz/v9KQWCYL&#10;yX8B/o4sIjeQMp/H6tt7620fvYDRf/jYalkg5wWcJiVO75Mw8SEpvzlNgsQ1EibWdCQo/CVYzJPQ&#10;NU/v8LQTwAtk12Irox0slslO0PskSLxGyr6OYaBYEzVYnCFf792keftFPMldulNT5ELY86Qf7jPy&#10;nO3z17cY50X2BEmaB8lV0r345CqtlUKecE+RReTfkWBxmvwsfkzKjO4hV1LvIwGjPYxsF72zAWZI&#10;EJmmd7I19WM3/gy3JU3zpNRmjowAPFv/7TNk0X6UBIv2pOOLJEyseKrT3ar/3ny9utyeynyq3s8f&#10;AI+TheGoTfIp5P9znLwIv07vjI9TrF1ZmWKB7MT9igTTfWR33tc9aeX6J4c+SkoMz2Go+FbjHira&#10;for7yGQMt4KltTFPzhv4PRlz+WuySF6oV+fnyMLyCFno7CAL5wOkZvV+Eiw20TukrH8yUnvScduL&#10;0AaJeXqnHJ+jFyI+JaVNp+kdUna1/vlF1vlsgZupV5cvkcBzkYSdkyQQPUvC1gYG04Nyu9qpSIvk&#10;//AZOXvi16T87TPSW7Mw6K/3uOv7OTtCwtzD5HXvIKMXUKVhsZ3sWBwkF0wcL/stxjlUtAfeHSQP&#10;Cklro53u83vg/yELyuP0LSTrCdPLXN8o/Tm5iv0GCRS7SA/UDL3Z+xvpnX68sf57F8nC+wq9CVNt&#10;cLjU9/ELZOdiqd4K9dyBtfkyrFzTNMu1HOoEva/L8fr7F0nYmiXhYi1KxO5G2/x+iQTGT0hd/2vk&#10;wL/j5P808ADXFX2jZt8C/hv5mfkZKTeUtHLbSLXL48DHpZTLTq27tbEMFaWUtnP/MXIg0H7cApbW&#10;Qls//2cyLvR16mFBNy4k+2b9LwOLdTF9lewwHCcL5/bk6XYM7XTf+yfplVnNkQVtewX/Wr21Jx2v&#10;W5/E3apfl8VSygVqQyAJFe+TBu5HSLjYy/CUsyyT791J0qPyLilve5eEizOk3MlSgXVWg+pZ0j/0&#10;Z3La9h7crZDuxCZSAvUyeY47XUq55IWSmxvLUEFedHcBz5FgsYPhLR+QRtlFsnj5Z+A3pNzl6u08&#10;4baL6XqbL6Vc5vqf05udb1H6btzq/aP4hF93c9rG8YtkJ+ctUsbyZL0dImVj/RO01ssSaWw/Q0LP&#10;Z6TU5iMSJNpJWpdYwylaui3tMIA3yONnB+lhGoZAKo2SadIL+DzprfiYugM7yDs1rMY1VGygd+Dd&#10;Hsb3/ykNSiGL36MkTPwrWVhevtPF5C1OLe7UE3ffQXlnSLD4kuxYvE12LZ4kW/EH6ZWLzZIXvrUo&#10;j1oioW+O7Ch9Rm9n4n3y/T9DgsQcKXkb+t2hcVd3Ky6SK6u/IYFiP905wV1aLW3D9v1k13gvcKqU&#10;su5DPkbBuC62N9ObKOMJ2tLqWyRXQn9PDjT7ALjik+zqqIvCa6QHpd0d+JQ0P99HGtwfIAHjfmAn&#10;1weMW51ifuPZIG05Wvu2vS2Rq90XSZj4mgSKd8n3+jOyW3Gh3sdlhqxfRSyQ3qIPSOB/kfE5B0Va&#10;b20Z1EHyXDw/2LsznMYuVJRS2uPVHyEPgNnB3iNp7CyTaUt/JmVPfwLOWz+/uvp7UEop7W7BGbI7&#10;sJWUtOwjAePBemvP/thEQsZmUvKyUP/aDfVjG0hwmCMvjldIgGhPQW9LnI6Svolz9KZrXSBBZx7L&#10;nIZW35kon5LdpdPkMTNMzf7SqJgiz7X3k5+jC3jC9jeMXaggOxM7yTd/FzanSavtMlmk/COZ3X3S&#10;aRhrqy7cF4CFUko7JeorcgV6K7mQso9sze8gwWETeT6cIWUv/e8r5EXxEr2+lkskULTjeU+T3ajz&#10;9BrjF6m7GYaJ4Vf7dL4mfU/vkcfHTgwW0kpNkufY++vbrzxh+5vGKlTUU7Rnyfi8B+mNoJS0OhbI&#10;AXKvkVrtz3Fu97qqPQvL9AJGOz3rQzIdajO9Eijqr7fW97fN3ddIqLhS/8wkvala8323K3jGxEhr&#10;mma+lHKETGY7SCYibh7svZJGzgS5ePMEqYT5iDyPukPfZ6xCBfmmbyW1xg/jLoW0mgpZwL5FTsv+&#10;mLtozNbdq1/7JWCplrpcJgGhv2digt5p5O37276Jtqm64fq+ir9M0/L7OxaOkwsBD5BgYaiQVmaC&#10;7PI9BRwGfkcuzBgq+oxrqNhHvvnj9v+TBmWZXJU5Qp5M38Y+iqHSBox6yOBN/8gNv79pWDBEjKXL&#10;pFTuT8Bfk/JgSbevITu995IBGbvJrr079X3GZtFdS5/aULEFJ1xIq6E9BfsyGW/6Gpn4dJxe86+G&#10;yLeEAsNCRzVNs1jHFL9HJkJJWrl2vOxecvF6UynlqmO0e8YmVJBv9kZyLsUuxuv/Jq2nQmrpT5GG&#10;4LNkEtDHpI/iPVL25BOpNDqukiurX5CyjS3YsC2t1BSphLmPTNg7T6+MtPPGaeE9Qb7BB8gZFbP4&#10;hCndjrYuf5HsPlwk5xC8RYLEV2Qxcrz++pxlT9LIWSIXCN4mhyg+jofhSSvVkAl7D5GL2Cdx1/4v&#10;xilUTJJv9AGyNeUhP9J3K2TKz1myM/EVOZvgbRIqviRXNS+Q2tFFdyik0VPPrbhMyhcfJa+T+/F1&#10;Ulqp9oTtg8BnpRQHllRjESpqP8VGUuN2kJQ/uUshfbdrZBfi30iQOEpvV+IMKZlY9BwKaSwskmEL&#10;7wLPkddMXyulldlE1pqHyM/SKTwIDxiTUEGvK38nufKyY7B3Rxp6hZy0+y7wDvArcs7BKXqnJXvA&#10;mTRelkh/1IfkjJmnGJ91gLReNpKdiufJRLVPMVQA4/Nk0pDyp81k+pOlT9LNLZKeidPkROx/IguM&#10;T0ivhE+M0pjqK4H6jCyELGWUVm6alA8eJg3bm0opc16EG59QAQkVsyRMLNXfS4r2MLOzwB+AN8ju&#10;xJvkQLs5XGBIY6+Olz1BdirmSCmHpJWZJuWD+8nF7Au4WzE2oWKKTH7aT8bkSeoppHfiHAkR/xfw&#10;OtmduEB6Jjp/hUXqkPNkp+JzUsphsJBWpj0XbS8puT9eSlnq+mvpuISKGfKNfQDPqJButETKHd4A&#10;/hn4F7KgcGKF1E1XSKB4i7x2zuDuvrQSEySQ7wK2k3Vn50/XHpepD5uAe+htQ43L/0u6W4tkktO/&#10;Av8n8Pfk7AkDhdRRTdMsAF8D75P+qs6XbUh3YIqEij3YywuMweK7lDJBein2km/uhsHeI2loFDIW&#10;9jXgv5Edis8AG8okXSTjo0/jFVbpTjTAbnJRezNjsKa+W+PwBZggQWIHaZqxNlRKoDhPxt39H6SH&#10;4uumaTpf8ykJSJP2MXLg5ZUB3xdpFDXkYrZVMtU49B40pAt/Q30rdd0ymfL0R+DvgN8BJx0XK6nP&#10;AtnJ/BpDhXQnGhImdpMhQZY/DfoOrIIpsu20A7+h0jK9HYq/J2dRHG+axvIGSf36z6y5OuD7Io2q&#10;WbL+3MJ4XKi/KyMdKkop7S7FTnIAyQwp+5C6qJDTsD8A/gH4n8BH5HRsSeq3TMLEWQwV0p3aRNag&#10;u4ANdV3aWSMdKqpJMs7rIL3D76QumidjIv+x3j4ArjZN46F2km7UhopzwCWcACWtVENK73cD95Lz&#10;0jq9WzHSoaI2nM6QpDiBgULdVYCTwG+A/0FGRV4yUEi6hWUy9elyvS3gTr+0UlOk/OkA2a2YGezd&#10;GayRDhV1m2kL2anw4B512VnSR/E/gbeBc055knQr9flhgRyOuYBjZaU7NUvOqthBxwcGjfo2zSTZ&#10;btpL70RDqUsKGQ35HvAr4LfAaXcoJN2G5XpbwPIn6U7NkDXoVjoeKkZ2p6LuUrSTn3aTYGGoUNdc&#10;Az4lgeKfgc/qabmSdDsWSbCQdGfaULEdmOlys/bIhoqq6Xs7iT0V6pYlMg7y30hj9vuOjpW0Am2j&#10;6S4cyy7dqWmyS7Ed2Mjor63v2Lj8xwtZYFlDri65ALxJr4/i4mDvjqQRU8jUuPbCnKSVa0PFDgwV&#10;I2+63hYxVKg75oCjpOzp34GvbcyWtEKFXIzwRG3pzk2RZu1t9e1UV0ugRj1UtI3a23DbVt2xDJwA&#10;3gD+BfjSsidJd6AhfVlzpFlb0spNkKMNtpE+3842a49yqGhIc8wu4B56Z1VI46w9NfttskvxQf29&#10;JK1UQ8o1CgkX7nZKK9euR7eRMqgZOnqhe9QX4VPkmzeN9aDqhnngCPBrUvZ0tmmapcHeJUkjbGN9&#10;606FdOemSahom7U7aZRDRUPuf8H52uqGRXJq9mv19ikuBCTduYYc2rWTjp8ELN2lSa6fANXJnYpR&#10;P9eh3Z1wxrbGXSHTnt4G/gl4q2maSwO9R5JG3QQJFHtIg6mkO9MfKjbR0VAx6jsV0+Sb19mtJnXG&#10;PPAZ6aP4PdmxkKS7sQycI31ZBXsqpDs1QYL5LKN/wf6OjXKomCSH9uypt06mQnXCMnCK9FD8DzLt&#10;yRd/SXdrAfiQXKj4CJu1pTs1QS5wT9Ph9eiop6m2MWYbox2QpG+zTKY8/Xfgg6Zprg74/kgaD4vA&#10;x8DfkzDxc+BhYAu+pkor0YaKGbK2niilNF27ADjqoWKy3jqbCjX2CnAM+Ld685AqSauiaZqlUsoZ&#10;4LfkuWUe+CXwOJ7/JK1EO555MynLn6KDg1RGOVQUcv+XyME90rgpwCWyQ/HfSR+F42MlrZoaLM4D&#10;b5Hnl0KqAJ6gw1NspBVq+3y319sGsjZ1p2KETJInQetANY6ukFrnfwDeBa51bStV0trrCxbv0TvE&#10;ayNwiCyODBbSd2snQG2ho6dqj3KoaOs9l/CcCo2fBeBz0pj9R3LInYFC0pqoweIc8CYp4ZgkpVAP&#10;MdprBWm9NGT6U/vz07kwPpJPFKWU9uC7CZIGPbRH46SQaU+/B/4F+MJTsyWttRosTgOvk0XRxnq7&#10;lxFdL0jrqCG7FG2o6JxRfpJoyP1vj0V3UoXGQQGuAu8D/0jKES4P9B5J6oymaUop5RRp3p4iF+5+&#10;Chz6hBLrAAAgAElEQVRgtNcM0lpr6E0k7eRo2VF+gmi/WRvxJFCNjyVS9vRrMu3pvGVPktZTX7B4&#10;nV6J8c+AB+jgQkm6TQ3pqdhGR3uRRjlULJO682vkCc8SKI26ZeACuUL4K+ALOjiSTtLgNU2zUEo5&#10;CbxBqgH2A/vIYsnKAOmbGlL6tIWsSSfp2Gv4SIaKehVlmYSJK/W2iQ6mQo2VeVL29K9kvONVdykk&#10;DdAC8DXwOxIotgKH8XA86VamSPCeAZquHYA3kqGiWiYhYoEsxqRRtkSas/8V+ANwqmma5cHeJUld&#10;Vi/gXQM+IaduT5Fdi4fJhTxJ15snr+ednP40ylcaGvJNW8ZzKjT6LpKm7NeBo03TGJQlDVy9uDEH&#10;HCUT6d4kF0A6VdYh3YZl4AxwnqxJS5d2KWD0Q0VDvomO29QouwocIdOe3gLODfbuSFJPXRhdAt4B&#10;/m9SDnVmoHdKGk6L9E6m71y1wSiXP7XbStN0tMteY2EROE5Knl4HvmqaxiuAkoZK0zTLdSLUG2QK&#10;1P3ADvL6Kykm6Z1R0aldChjRnYp6+F1720zGdxkqNGqWydW/D0lZwUdk10KShlHbuP2HevuSDl6N&#10;lW6hoTf1qZM/F6O8U1HIVd5pPKdCo2mBvCj/EfgzqVNeHOg9kqRbqLsVF8jz1S4yZvZecl6UpPws&#10;TNMbJtQpI7lTUes7C2nQvorTnzR6lslj90MSKj4G5rvW1CVp5CwBZ8lgibeB09i0LUFCxKZ6mwYm&#10;a2VNZ4xkqKjaqU+XgMt0sHZNI20BOElKCN4FzjZN48ABSUOtXvhYIIdzvknO1rlER8s9pBtMkhKo&#10;KdypGCnLZIfiAhnHaajQqChk5NyfSdPj53ilT9LoWCa7Fe+T57CvsGJAKqQCYW7Qd2RQRjlUtOVP&#10;hgqNmnngUzJC9m3gnGVPkkZF0zSlaZpF4BgZMvEuGTHrbqu6rJCfg7Nkfbrctdf2UQ4VkKsll7H8&#10;SaOjkBGybwB/Iidn+0IsaRSdJxdGXiN9YZcHe3ekgVui16TduZLAUQ4V7fSnKxgqNBoK2Vn7kPRS&#10;fIYjZCWNrnkywe5NcoDnBXwtVrdNkb6KdqBQp4xyqIDUobflT17t1bBreymOkFrks/i4lTSi+k7a&#10;/oSUQH1FBxdSUtV/TkUnX9tHOVQUeo3a50nA8MlMw2yRTHw6QnYp5rpWbylp7CyRA/H+DHxAdl87&#10;V/YhVTNkbd3JM6dGOVRAvmlXSfnTHIYKDa92tvsfSenTcTp6JUPSWGl3K94hz2/HSJOqr8fqogl6&#10;5fmOlB0V9QrvMlmYLZBQ4dURDat58mL7B+AjPOhOY6qUMlFKmay3zr2odk19Hmt3Yf8A/AY4hRdN&#10;1D3L5LHfHgjZudf4qUHfgVXQHoJnqNCwWiS7FO+Q8oAzdPDJRuOpBocpsu2/id72f8mHS0Ovxrgd&#10;rLFEB8ctjqv6fZwrpXxEQsVjwE7GY40h3a5l8vp+hjpSdrB3Z/2Nww/8Anmhso5Tw2qelDv9mexW&#10;2EuhkVZKmSBBYZoEiW3ALmAPsKV+rOn7MxvIhZ8TZFrQReBiKeUysOBY5bHxNZkE9RHwMLB5sHdH&#10;WlcNeb2/ijsVI6k9vfAcToDS8LpKwsQH5FwKT8/WyCqlTAOz5Er0LmA/cC9wsL7dQXYrpugFio3k&#10;4s+X9fY5OdfgM+DrUspF8iLs7sUIa5rmSinlc+At4AUSMkd9nSGtRHtBZRlDxcgp5OrXeQwVGk7t&#10;ZJT3gKOkoVEaSaWUSWA38ARwGHiIhIq9JGBsJ4Fjmry4trcJUg7wJAkXJ8nV7HfJuS2fkuDdnkSr&#10;0XWO9FY8Qx4rBwd7d6R11emRsqMeKqAXKi6QK13SsCikfvwoKX36imyNSiOlljttITsRzwCvAC8C&#10;D9T3byQ7Em2YmOCbk09mSZlUqX/PfcCj5OfjCPkZebuU8gVwxR2LkTVPzq34IymB2kUeHzbta5y1&#10;xxxcJK/7nRwpO+qhopCrWhdJsGjH2PnkpWFQSMPWR2Sn4nzTNPb9DIG6SG5vDb3TT5fp681yYfuX&#10;r9V24BHg5Xp7HjhU33+7z7dtjwXAVtKLsbv+PU/XtzuAX5OgMXf3914DsEim37xJGrYPkgA5M8g7&#10;Ja2xNlScIjuu9lSMqAWSCi/Qa9ae/NbPkNZeIY/Nr0gvxRd09MrFMKgTiNrm4nZK0Sy5ut5OKmoP&#10;LLpWb1dKKdfo1fp3KhD2TW3aRnYUfgz8EniOlDtNc3cXcKbILscsqb3fTa5ozwNXSynHgWsGu9HS&#10;NM1ybcB/H3iDhNHd5Ps9smPspdt0kZQ5W/40apqmKaWURVKje6G+XcRQocFrS5/eAv5E6ow7tSgd&#10;Bn1hYgNZHO8kC+IHSFnGlvqxGXLVfTO5OPExqfc/Tq48nakLpaUOLXLbHYqngB8BPyU7FHvJ12w1&#10;tMFlgvRmvEiexxeA3wJfllIWOvQ1HxeLpJesbcY/TH62DBUaVw250LJERw++gxEPFdUy1zdrL7B6&#10;L3jSnVomi6MjpJTDhdE6K6VMkRDxAPBgvR2kN61oG7ky3vYBtH0B10iQOEF2mN4jZ4x8DBwvpVwa&#10;9wlefT0UjwM/J4HiCVY3UPRr6t97EHiV3k7fNdLU7S7fCKnPdfOllFOkAf88ToLSeGvP67lZP1ln&#10;jMMP+DLZLm/Hyo71i71GxhxZiL6Ph92tuxoo9gEvAT8jtd0HSBnGVlJy0x7S9o1PJ8HjMKmNPUx2&#10;Ld6vtw9qM/HFMT5fYSOpg/8h8Nek5Gkba18Xv4n0VkyS5/SzpBTqwhh/rcfZBTI++Bj5eZzG3QqN&#10;p2Wyy32NXATpZGXCOIQKSKg4T69ZWxqkJXKl+5/IVe55dynWR73Cvgm4n5TS/Cfgb0ip0xS9K0jf&#10;diWpv6F4N7li/wDwfbJb8TppJn6nlHJ23HYt6tdwJwlTP61vd7M+i8GGXrB4hewWnSNB7qo/RyPn&#10;EhkX/C7ZHZytN2nctCV/p0mVQpdKZf9i5ENF7atYIFdEDBUaBhdJmHiXHHZn6cb6mSVnIfzvwC9I&#10;k2h7wvOdaMty9pKF9kESMA4Cfwf8vvz/7L1nkxxXmqX5eKRGJpDQBAGQoGZRgaIUS4vu6p6e6e6x&#10;td39m/tlx2xnp7tna0qwWCSLWpNQhNbIBFJnxt0P5156IAmVQEb4dffzmIUFFAlHhPu997zivCFc&#10;algUfRRldb6P+im2M/jo8gjKLv0MCfSLlBFAUx/mUQnhp6h8bj8WFaaZrKFz6MX43qQ94Z6pvaiI&#10;LKNo1kXUHGtMVSyjxsS/oI30WrWX0w5idH0rOgSn7MSzqIznQUmZi+QcNYS+5xlU5vZxw4TFbuAl&#10;VDq2j2p61AqUXXoeRbrfR2WEFhX1IvUnfYVKoJ5H36sxTaRAZ9DWztlpiqhYQbW3Z9FGv0pz/m2m&#10;XsyjwU9/A846S9F/oqDYBbyCshO/QkO3NkNQrKdAkdbHgZ9T1s1+GEK4XGfb2eiUNYGas3+ERNlU&#10;hZc0jDJETyBxcxTVLJuaEO1lb6BsxVmUxV3DDo2meSQn0jla3NvblIP3Kko3nUXRrGW0aLW2A99U&#10;QhdF5b5EA+88PbvPxIPwJJry/C/A39P/EothFG19Mf44bSYLIYT5GguLJM5eoJxFUfXhL5We7QMm&#10;QwgzbY0A1phlFPRLZSErtNwhxzSOgLLW54iB7RBC0ca1qhGiIvZVLCFBcQVFsyaqvSrTMtJcii9R&#10;qcZ5XKoxCFL9/28oXZ7SpOx+MoRmOLyEvveLSFCeCiEs1nQzGUHNtE+hz7RqQQG6pu3ourYDl0II&#10;HohXI3r252uUfY+2fTdNokBBxJPEadptXaOaZO22hpwmruG+CjN4VlGU4h0kKuZqHLGuBTFLMYXK&#10;dH6GmrIHObW3g7IkT6JyodcobTNrRU9PyjPo89xNHpHkIfQdH0DX1I+SNtN/ltGB6xu0R7fywGUa&#10;z3UU1G7t3t8kUdFFouIySrF60TKDoovuuQ+Ad1H9sLMU/aeDypAOI0emKrKTBfAQ6uf4ITr81jEK&#10;O4wyAa8gkTRBHqICJCT2otKscfK5LnPvrCJR8RXK4np/Nk0izaiYR+V9FhUNoItU4jmUfvKiZQbF&#10;MnI2eQsNR2ut88OAmUIH4FdQKVJVn/kWNCjuWSQq6miZOYr6Fp5BB/ic9oZhlEWZQlkgP1v1o4sm&#10;o3+JxEVrD12mkSyigHZyBGzt/Z3TxvGgdFHZ0zn05XrjMYPiBhITHwHn7PjUf2Lp0wFUdvQSEhVV&#10;rmejqDxnP7AthJBDP8JGmEQuS3vJL9PSQRmKEaCVzY91J5aC3kDOeCdoqYe/aSwLSDRfQKXPrV2j&#10;miQqAooYp2ZtH+zMIFhD99snqF7Y/Tx9JgqKEVTy9BLVzVLoZQQJm32ojGi02su5d2I/xU7k+rSH&#10;/HpCOuj77Z2IbupHFxkanMVDak1zSEPvziJR0WrXxyaJCijnVVym5SkoMzCuocnZ7wLni6JorT/1&#10;AEmD0Q6hsqMcmneHgG0oe7If2BoP63VgHImJR1CZUW7XPYQyKWNAJ4pKUzNi9PY6ckmbw9kK0wzW&#10;0LnzJLq3W30GyG3zuG/igrWGDnmXUKq1tSkoMxDS9Ox3UKZittrLaQ3D6OCek/VpOvjuQ/an08Bw&#10;TQ7Ak5SN0FVnfG5FcoAawfMN6s4iOnx9iDK8Fham7iQ7+Qvo3Nnqe7oxoiKyRtmsfRYtYMb0g1T2&#10;9CnKUpx1lqL/xOj/BIqqP4MO8TmsYwUqedqBsihT5CF27kgUPVvR57iL/EqfQJ9tatDuYlFRW2K/&#10;2RHgv6MJ6d6jTd3poHL7lH1rdTA7h81404jZikXgOPAesq5z7abZbFL/zgkkKD6l5SnPAVIgUfE4&#10;yggMkc8hcwg5P31bqlPt5dyZKCiSEDqAshU59oKsogz0dfTcuay13qQetOO4B83Um4B6KG4gO9nW&#10;r01Zb3r3yQoSE58BZ2h504zpG2so0vYF6uFp/WIyIEZQ/f/TKLqei6AAXctwfEE90uBpMvhDSAzl&#10;uCcsomftHLDQZmeVhjCPBMWXyILTmDpzBVnKX0bnzVavTzluIA9Kapo5hr7ohWovxzSQNdS38wXa&#10;HBc9PXtgjKOypyeRy1JuomIEZSmGqIfQ7KDPcQ/5uistoQDRRbye155YJnoZlUFZVJg606UUFZeA&#10;5bYHPRonKuIXOod6Kk6itJQxm8kiirJ9jHspBs0W4HuoQTu36cqpnGhLfO9mvsGkUrJdaMbGEPlF&#10;2QKKbKfBUi5nbQaLyOTiatUXYsx9kkqfLqEs6jU8yqB5oiKyjDrxj6Iv2pjN5DpyL/kC318DIw6U&#10;m0a9FDvIr6m4N1MxfJc/mwMFEhT7UXP5CHmJNNDh8wKKBM46I9gYVlGZ8hnkmufv1dSNLrp3T8fX&#10;DXwfN1ZUJBeo0ygS4kiy2SzmUYP2x8AlH3IGyhQaePcIqv/PkQJtLAEYytxStkCzNXagrE+O+0ES&#10;FUdx1rlJrKLv9W20lra+Ft3Uki4KLF7F/btAnpvIAxMPemkzuojKobxgmQeli+6pD5ERgOdSDJYJ&#10;lKV4FJUY5UZyn7tMPe6NDhJq0+jzzE0ApdKnc6iU1f0UzSEgkXgclUHN4z3a1It0v95AQezcy10H&#10;QiNFRSQ1gx1FGQtHQsyDsgKcAv6GshU+5AyW3vr/HIe0rSExcQ5FrtZy3WRiBmUcZSl2ocxPbqKi&#10;iz7HVHvf+nrlphCfi1XU5HqeeCir9KKM2Rir6IyZ7t8s1/pB02RRkRas94GP0KbkRcvcLwGJiOMo&#10;UzGb64GxiYQQRlBEfQ95zlKA0nnuMvlPVh1CQ+/SfIox8hMVq8hw4ytcWtBEuqiS4Bv0zOT8vBiz&#10;niU0o+oYFsXf0mRRkVLn36Av3bMEzIOwhkowPkH3lF1oBsswaih+AUXYc2QFHZKuAkuZi84CCYkD&#10;KPOTG6k85hTKCs67f6lxpD36KnL28vdr6kSaiXYJ2crnvN4PjMaKivgFr6Aa+BPx3ZEQcz90USTi&#10;beCvOOs1UGKpzhga0PYoeWYqUunTGbTRzFd7OXdlCPVT7I7vuRFQA+QF9Lm69KmZLKGKgkt4fzb1&#10;YRGV1R9HAWsHGSONFRWRNRQBOYluAG9M5n5YAr5GguJz8o9CN43kUrQLNRQPVXs5t2SVcujmBfIv&#10;1xkHDqLSp9zmfUBZvnoJN/E2mUUkwk/hg5mpD4sogHQCuFYUhQVxpOmiArQhnUGK0j7CZqOkiZlv&#10;otKnGZdhDJw0T2E3+a5ZKyiyfgxtMrkfgseAp1H2J7d+ioAOmKmJ16UxDSQ+I0vI2OAodmk09WGB&#10;cuhd7lnpgZLrBr0p9JRAXQSOoGyFo15mI8yhDe9d7Pg0cGLp0wgSFQ+hjEWO61Y6BJ9C90zuDKHP&#10;cpL8hggmS/DLaO2+gdfsprKGxPhpJB5dTWByJwnhL6hHVnqg5Lg5byoxLTWDylfeQW4iHoZn7pW0&#10;gBynHhHoprHe+nSK/NatgATFF/E96/UlhDCMnLTSfIocy8lST8UM9n9vLPF7vYGqCS7gEiiTN2so&#10;2PEFqly4hrOoN5Hb5twvFpBjzztEJ5FqL8fUhBW02b2P+nIWq72cVlKgxuyp+Bohr1KdxGVkL1iH&#10;Up1xZM37EJr9kRtdtEafR5u2aTBFUaR+pPN4jTV5E1DZ01eo1NWudOtohaiI2YqrwJdIVFyv9opM&#10;DUiR0o+APwLn4+ZnBk9vqU6OEes0aPMU2mRyvMZehtHnuY88RcUqKns6gyOBbWERPT+z5PmMGxNQ&#10;puISulcvkXlWugpaISoiy6iM5RgqUfDCZW5H6sU5iUTFEdxLURUFOgTvQeVPuRFQwOIc6qWowwE4&#10;9ansIE973jT07hI6bHqtbj7zyFnvBPXoSTLto0vZ/3MWnQns+rSONomKlK34CtXHOyJibkcXRZ4/&#10;RqLC0zKrIx2At5JnPwWoFvwoEhZZR65i4/skEmlTSLDlxhoK/FzD9s1tYQGJik+RmDQmN9IE+GPE&#10;rDQ+Q36HHDfoftFFEZCvgQ9QRCTrA4CpjGQjewT14vhgUx0dVKozgQRGTv0UKaN1FUWurlCPyNU0&#10;8Aj5WclCOWX5W1FR7eWYAbGCnqHjKKDjII7JjWUUQEqlT8s+F3yX1oiK+OUvoxviQ9S979S6WU+g&#10;rO89jhYP91JUxxDl0LscD8BLSFRcBRZz32Ti9U2ifoqxii/nVqR5H+eAWQ+Vag1d5AJ1DomKVbw3&#10;m3xI5hFnUa+XK11uQ2tERSTZyx5DUWiXtZj1rFKWPn2BDotePKojZSq2k2dT8RJyrblY9YXcC7H8&#10;aQwJizHy2wNWUJbiG2yo0SbSoe0cepbsAmVyYpVyuOlZYCH3AFJV5Lah9JWeYXgXUPnTFRyFNjez&#10;jBaNz1BDllOc1dNBPRWT5JWtSG4g59E9k/V90tNPsQ3ZyuZoz5syhWex9Xdr6Nmbr6PAn+vVTU4s&#10;o6qF47h64Y60SlQARE/hWaQ4P6dMtRqTBjF9gxpvPeyueobRwbdDngfgJXTPLFKPrOcW5Pq0jTyH&#10;3i2gNXkW97y1jS4SFen7r8PzZJpPGniXnCBnPJvi9rROVEQWUKbir6hx2xZ2BsrF4wNkJ2sb2QoJ&#10;IXSQ5ekkeR6A0yGoTs3EyUlrO3l+ptfRszePD5VtIwX8zqMqAn//JgduoCDj31DA0eeCO9BWUbGK&#10;Fq53kfq8Uu3lmExYQSVPbwEX3CSaBaPAXtRPkdshI/mWp/kUuWe1UqZnDNnJ5pb5AYmKNKsg98/T&#10;bD7zqLzEDlAmFy6jqpYv0VnRGdQ70EpREUta5lB93CdIYHgDazdpgvZxHI3IhfRM7kA9ALkdMgI6&#10;BF+jHvX/aebHeHzlKCoWiDX1FvWtI/VVXMOZCpMHAa1H3yDXJzdo34VWiorIKlq4PkXZilPUw2Pe&#10;9IdVJDB/j9xH3GdTMXHxDuggnHorcqODBMWNGmw2BSp92kaen+c8Kn9ZwM9fW1lF98BVfA+Yaumi&#10;rNmXlFkK35N3oc2iIqDN6xgqd/k0/jz3g4HZfLqo7Okd4D1grgYHxMYTQhiitD0dIr8egDV076zW&#10;KKq+FQ2/y63xPa3HM6iGuS6fp9lcVpG4TL1KXodNFSQXumNortnXaF1y9uwutFZUxEPjKlKiH6Js&#10;xQzezNpGKoX7AHgf2Q37HsiDYVT7P0x+a1UapjkLLEe71twJqOxpgvw+T9B6nMrJvHm3jLgnryEx&#10;MR9fXotNFaRhjF8je/mz2F7+nshxYxkY0RZsEbmNfIFKoDxlu12k5uz3ULbqmu3ismEIHYJzLNVJ&#10;ouIsEqW5ZVFuReqpGEMN8Dl+potIVPgw2U7SELxrOMhnqiPdh8eRccQMPhfeE60WFfCtsJhB3f1/&#10;RcKiThaR5sFIkzKPY8enHOlQCouc6MTXFWpgSR3tebcge94tSFjkJCq6qPzpOh581lpiJHiB0gFq&#10;udorMi1lHs2k+AJVL6w6S3FvtF5URBbRofJN4GPsPNEWkqD8AtVOzlZ7OWYdAX1HW1CEPTdSpnOJ&#10;/COqBcpOJOen3KZp9zpprWJR0WaW0H1wCdt3msGzDJxD5dBf4yzFhsgt+lcJRVF0QwiXkaA4AOxB&#10;B5ntlV6Y6TddJCDfRZZxi9VejllHQAffKXQgzok1yina3ZpEsQrytZMtUMbnetUXYipnFdWzX8ai&#10;wgyeG5QN2qexjeyGsKgoWaIcfPYQsBu5pOS2+ZrNI01E/gK46oUjOzqUcxVyW6uSS00SPnUgoGBJ&#10;joMEQRHCJeoxSND0jzUkMF3+ZKpgBpU+HUHnAtvIbgCXP0Vib8V1dCN9iJq3V/Dm1mQuI0FxEffR&#10;5MgIylKkMqic6KIDT+5lT70UaEbFVvISQsmJbxHV09sso9100Xo8h0WFGRypn+c0OhecxdULG8ai&#10;4mZW0dCdI2jYyXksLJrMZWQX59rdPBmhPADn+Ax20X1TB2GReipSpiKntT+gQ+QCyv4s2oGt1aSm&#10;/TSp3veCGQRraGr2Byiw7HPBfZDTxlI5sfxlGSnVdGPN4EWtiXTRpnUKmLXrU5YkS9ncmopB11Og&#10;w08dNp4CCYpkJZvb2r+KhMUSnlrbdpKouIT2X2crTL9Jcyk+A94GvgLmXRK9cXKrU86BNVQO8z7q&#10;rdiLDjZT5HewMfdHGnh3ETVqe9PKmxHymwORRMU8sBJCKDLfgDoo65Nbw3siZStWyE/wmAFSFEUI&#10;ISyitfkKKkEZr/aqTMNZQiXv7wGfoIoVBxrvAy/e6+jxyT6Bmrb/Gn+8UOV1mU0loNKnI8jloQ6R&#10;5jbSRVHrHCdqJ1aAlcwFBZTOTylbkSNzKFpY1GRCuekfyQHqCt57TX9JZe8fowqV08BSDdb0LHGm&#10;4hbESMksSoH9BWUsdqIN2dSfFGWeRX7UjkhkRjxUFkhYDJGfqEjN48Pkl0W5HV009C7XqO88OkgG&#10;b+itJ000vhzfjekXyQHyLUonSJe83ye5bdTZUBTFClrQPgE+QlMVTTNYQ4eXWdwUmjM5R6tTk/YY&#10;eQ7mW08HfZ5j5JepCOiZXKY+je+mvyQHqBnswGP6SxIVH6JGbTtBPgAWFXdmEdmKfYTcoK7ipu26&#10;E9DB5Qgqa8OlFvnRE6keIs+5BUlU5JhFuYl4fw8j16dR8rzeZfSZ5ur0ZQZLMk2ZxeVPpn+soN7K&#10;r1BPxQ1nSR+MHDeXnOiiRe1j4P9DrgBzeNOrO12UgfqEetTDt5UOiqyvkWf0OlCDtSDe3x3KyeS5&#10;XXMqdVnFe5IRyQHqAtqDHcwzm00X9U+8i4x5LuL+ygfGPRV3IPZWLKNsxTvAw8ATqNxhjLzLM8yt&#10;6SJheB1lorxZ5UuyPl0lv++pIE+r29sRKNes3D7L3jkVdmIzoHt0EdnKXkOHvWSHbMyDkoYdf4Z6&#10;KY5gC9lNwVGhuxDr7ReQS9CbwBuo7s6Ktp6sAEdRg7ZrJ/MmlRjlKCrSDI1hoFODErpAnta8iWTP&#10;60yw6Z0ZNYv6KlwCZTaLgATrMeBvqLzdg+42CYuKeyAKixlULvM/UDnUVbz51ZEVVDt5CtdP5s4q&#10;cQ4E+T1raUJ1h7IJOmdSX8VYfM/tejtoo7fTj0msIZF5jegKVu3lmIawikx43kMVKCeQYYvvr03A&#10;5U/3SFEUqyGENBTvMWAPanycJN/on/kuaeFYxNGv3FlBh4rUwJsTqTQrWcvmThI/Y/GVE13s/GS+&#10;S6oSuIpKVXzoMw9KGnx7FPXIfo4NeDYVi4qNsYQae/6ANuZV4HlgOxYWdSA5P60Bq45MZE/KVORI&#10;OqQPAUXOtsSxNCv1f+ToVtVFkehl8hOPplrW0Bowj0WFeTBS79YZ1Jz9MXAeWPZZYPOwqNgARVF0&#10;Qwg3kLodoYz8vYSyFiZv0qKSGv9M3iSv+lVKp6WcDp0d9Nznvo520Ho1Tp7Bj4BERbLoNQbKINB1&#10;dH8Y8yB0kZvYhyhLcRyYs6DYXHLfDLMjlkFdBT5Fm/RuYC+wn3q5wbSRVKN7GpgLIXRyjjAboCyN&#10;ya0sJgmcSfIbJncrhoBpdK1d8stWLKLv2OunSaRm7RlsK2sejIDuoS+Av6Lm7MtxyLHZRCwq7oMo&#10;LC5T3qB70We5D3+mObOKFpZTKPpl8qaDnqdUspbjgXML+U/UTsMDt6PMam6RuTRR2z0VZj1LKEsx&#10;h9bvOgh4kxfJ7Sn1UbyDzFo8qb0P+AB8/6yierx3gG3Azvi+lTwPP0ZRrytIUCyT3+HK3EwRXzlm&#10;KkDR/zSlOlvivJ01tN4Pkd/61KWndt7lCCYSKO2k049zK4E0+bNC2UfxFvA1Knty5qsP5JYCrw1x&#10;45sHvkHq9010s9r6Ll9Sjf4a0PXhJXuSs9ICOlDkRG+fwmgIIdu1NF7bGGWTdk6HsnRYLIA1lyOY&#10;daygoMJSfPkgaDbCGgokfoTOaJ8CV4qiyG0/aQzOVDwAPY3bX6OheNtRpuIx8i+JaCuppCangwZ6&#10;K7AAACAASURBVJW5NenAmYRgTiRHpSHKDECuB54R1PuRBEVO934qfVoFuiGEwmLfwE0Ztt5Bkznd&#10;uyZvAqpK+BqVqX8AnCmKYrnSq2o4FhUPSFEUa7Fx+yNgB2rc3oLmWLhxOy/SALDk3GXyJh04U/lD&#10;TiRxCjr0jIQQcrUpToey3LIUiWQpu4qu1VFEkwjo3t1OKYyNuRvJ6fEUmpqd3J5ytShvDBYVm0Pq&#10;r3ibclP8EXCAzOutW8RNEdGKr8XcG8n5KUdRAaVATVOqcyaJoNwOZUnoXEONkzmKHlMtnrRuNsoa&#10;pX3sm8hUZzbToE+jyH0jrAUxTbuIHAWgbDz8GfAo3ihzINXmX0NR0dzKacx3WUPf2Up85WaFOoSy&#10;khPkPV8hrUej5HmdQ+h7XiJP8WiqZQbVxfveMPdCF7k8fkaPfSzOgA4Ei4pNIvZXzKHG7YA28GnU&#10;Y7GdvA5DbSVFvheBNddvZ88a+q7SALw18nqO0pyKXIfKJVLD+xR5Zk5X48uWsmY9HbQG3MAZZnNv&#10;LFDax76LSqCWvNcPBouKTSQKi15HqB0okvl8/LF7LKojlX8MUdbpm4yJGcAkAlMZVE50kKiYIC+x&#10;cyvSteYmKlZRaUsXCN74TSKEUKD7Nk3WdqTZ3I0l4CylfewR4IbtYweHRcUmE4XFArqZ/ydaDBeB&#10;lymbt83gSRtUgQ4wtpStB2kKeo5zRQo0myZlAAryu0YoG7VzDGikEjdnKMytSPdsb39V7gLeVMMa&#10;cAm5PL2Byp+uFEXhtWWAWFT0gR6r2a/iL3VQxmILKoUy1TCMorVT+N6vCwHVx6Zodk6k8qdtlO5K&#10;uV0jqJE8lWDmJnpsoGBuScxUdtG+OYnuk9zuX5MHAfXdvA/8OxpKfA4JUTNAfLDqE1FYzKKMReqv&#10;GEGlUNPkGTVsOsNog9pGfmUgZh2x/KFAgmKR0gUql2enQAf2LURRkWmfzggSFUn45ETv1HSLCrOe&#10;lJlI90huz5apnjSI+Avgz6js6SQwn+Fa3HgsKvpIFBYzwJdoQwdFW15AwiLn5s4mkspAcm+sNTez&#10;QJ6HzjQAb4LSASrHidBp+vcE+a35vcJxJVNRZqojzRuYQ+tAbmuAqZ4l1Jj9BvAX4Bjuo6iM3DaY&#10;xhGH411DtmZrlIeOV5AzlBkcHUpbzVyi3ebOdCkzFan8IZfvrkD301bKkroc+yq6aN1JRgU5kZyp&#10;5tDhwJj1zCNb2UXye7ZMdaQ+m3PAH4HfA58C1y0oqsOiYjCsAlfRDd9BB5DdwGPk20DZRIbRZ5+j&#10;C465NavA9fjKbY5BmtC+DQmL3A7sqYRsiHwnySdnH5snmFuRjDWS3bDvDwO6D26gMqf3gP8APkZz&#10;qNyYXSEWFQMgbpQrIYQrSFikw8cvgWdQKVRum30TST0VY8BICGHIzhD5Ehs1kztQimTndqjoUJbU&#10;5Ugq0RojQ9FD6f6U3NmMAW4SxMkAIYlP024CylB8g3oo/oAatC8CKw5MVItFxQApimI1hHAJPQBp&#10;oM8cat7ehe1m+80QqiufouyrsKjImzW0gcyhZyYnUj/AODq0p0bynAiUwif9PCfSnArPIDC3okNp&#10;hjCGhafRWnEOZSj+F5qafRYPuMsCi4oBE4XFFdRjsUxZL/4iKonK0aGlSYwBO1G5ygi2nNswIYQ0&#10;SHCN/pespEbN6yiinRvpwD5Gfgf2lO1JvR85ip4uWv/myLPJ3VRLgQJBO+PLZ5Z2s0ppHftGfD8L&#10;LFpQ5IEf0AqIzdvXkSvUGhIWV4FXgUdRJN30hxEk3nYAoyEE285tgCgoptEGfx01UPazwbaLxMRV&#10;lNnLjRRJzTmKmkRFjnMqUj/ZLPllokyF9JQ/JoONZIRg2st14EPUQ/EmcApnKLLCoqIiorCYQQPy&#10;FtHDkgb9WFT0jyEkKJJvv9kY24AfAz9Bi/tfgDN9/jtTs/YN8jsUJyGRmrZzdH9KwidHg4JUN7+M&#10;MxXmu6TBiKvo/sjt2TKD4waaRfFvqJfiKDBnp6e8sKiokJ4BecfQpjpM+Z3sJ78DQBMYQlH2XSit&#10;bu6BEMIE8AjwfeAfULleQI4bff2r0YHiRnytkk/EMh2Iu/GVy3WtJ8TXGPldX/rsIL9rM9WT7gmL&#10;ivayilydvkI9FH9EQ4WvO0ORHxYVFRNTvPPIGu1PlPXFvwAOoMxFrmUVdSRlKvbF95M4QnpLetxX&#10;poBDwG+Af0RleksMruQniYpUIpPT4bhDGU3N9TktyLcReg3dS2mGRq7XaQZMXH/GUPBnnHxFu+kf&#10;qYfiQ3Q++iMqG79hQZEnFhUZEIXFIrE+EB2eZoGfA0+hkhMPbNscUk/Aoygb9FUIYc0p1JuJG3rq&#10;P3kWlTv9GjiMmtwvouhRvxvdU6biOmVfxRR5HeADOhxn5yQWQhimtJPNcRNOcypG0H7kAXgmkZq0&#10;dwMPYev1NpGyq9eBT1APxR9Q+dOsreDzxaIiE3qExXlKm8VLaJbFYWAPjtRsBh2U/XkYOIg2qkXs&#10;AvUtPW5Be4HXkJh4HXgClY6lBb3v5QjxuVihnKp7HR0ycrFfTtkc0DXmJk7T/IdhtK7kNJEcSkGW&#10;47RvUy2pT2kryipPYFHRBtIcitRz+h+UGYoZMgzemBKLioyI6bylEMJFFLGbQ84388BL6CA8SV6H&#10;grqRUurPAK+gtOpMCMFDc0omUCbnB8CvgB+h6e+TlAe/FP0eCiF0+pzpSQ5QMyhbcZA8JtGnKPsK&#10;el6XM7yH0hTiJCq65Hl4z+1zM3kwjPrfdmFB0RbW0ByKD5HD0/9CguJaURQuj8wci4oMKYpiJYRw&#10;DaX6VihLP15Bte3T5BOprSPDqF/lBeBJ1Cjf+gFcsVRmCgmIn6MMxSuoTKz3ED8Uf55KVtLE275d&#10;Gvp+LqJM3pPcLHCqIqAs1zl0bbllKZIZRJfSTjY3UdGJr2Va/vyZ75CyynuQqKg6iGD6TxdVaLwH&#10;/DsSFUdRU7bXhxpgUZEp0XJ2ltiUhB6088APge+hhTZ5z5v7YydlSc9VWnyoCSGMoHKn76H+id8B&#10;z6Gyg/X9PKnfYuQWv9cv5oDTwHEkBtN1VUlA1/U1Eqa5Rtt7xU5uB7M0g8AliGY9Q6ifcCf59VGZ&#10;zSX1zs0A76KSpz8hl6d59zzWB4uKjFnnDJWExTngAuWgPLtD3T/TSFQ8ApwNIbRyKmcIYRSV1v0S&#10;+C26tw6hWubbHdyH0b3X9zUkPgcLaHLqEZQV2I9KsKpkFYnR0+jZzHXjW6WcRp6jqBihbMw0JlGg&#10;NXoc19E3nQVkVPMu8HvKDIUFRc2wqMiceMhdjH0Wi0jJX0IHqx8id6iduBzqftiKPr9X0AC3ecrD&#10;V+OJ07G3IWH1IyQovo8Ext3sYocY7ADBZC14HH1Xz6DvryoCEvofoixFzvfNKsqo5HgwS/MHOuQn&#10;eEy1DKPs6U48s6nJLKPA6RvA/wT+hgSGB9vVEIuKmlAUxWrss0jTty/F14+B59HcBbtjbIwJ4HHg&#10;p+hgeL4t2YoQwhCKAr6AxMQvuLms7m6kBsqBDBCM2Yo5JChOUbpAVXW/L6KN8C107+Tc6B9QI3lq&#10;2s6J5HTXwXMqTCQGPCaRqNiN1hmLzmbRpexJexsJijdR5rcV+3ATsaioET22s2dQlPQKKoW6yM0l&#10;K7aevTeG0Yb1MvApSrfOhBCWmhohWTd/4mXg7+LrGTa2cafJ5IOcSr4MXEYlUCfRv2GKanor5pCR&#10;wifAhVybCKN47FC6VOV2Xydnr2R9awxobZ6mnE/hs0qzWENnmG+A95GgeAudbSwoaowf1JoRH7bk&#10;DvU5Koe6gJq4f4QGlaVos4XF3UmH45+hmv2rwMkoLJq4sI2g8qa/A/4PdM9MsfH7JUUSB1aWEJ2M&#10;ZoCPKAX0s1Rjs3wdlWKdRZH2nEk9FfOUg+ZyWRuSLW9u8zNMtQyh5/sAEhWmOayg4b5H0UC7P6M1&#10;3YKiAVhU1JToDpWauOdR1uI8EhiHUfOxHTPuToH6Al5EadgTaMG7TMNKMUIIUygj8VvgH9Bgu133&#10;+b9bRgJsicEeBueRI9pfUWnELiRsBllzfRX4GKXqz6JNMle66Prm0X29RJ6lJKvk2fNhqiGty48g&#10;pzfTDNbQmeVDtIb/FWV8L5PnnB+zQSwqakzPsLzzlMPBLiLFfxh4GqWPB1miUkdSf8HL6JC4CLwX&#10;QriUa1nLRoh2sVvR/fAr4J+RiHqQCOAaitavMcDyo9hbdBmVqz2EmsULJDD6PRBvBQn3j5Dl4fvA&#10;TM4bYSyZXKXsxVoir76KIWQKsEje4swMlmGUgZzEJiRNIGUnzgHvoAnZf0PlTzNFUTig0BAsKhpA&#10;zFrMoI35KooEHEGlLa+haE/qtTC35wAa+JYmJH8QQrha1/6K2D8xiqL5z6OG9F+i5uxtPFgWK/23&#10;I/HvGKT70RoSzm9RlvK8TOla1Q9WkOD8M5rw+hfgbFEUdTgIp/Knmfie0wC81EuxXNfnzPSFCRQo&#10;KND9a/en+tJFlRSfIiHxFspUnAQWcg7KmI3jQ2ZDiPXmyUlhFkVUTyInhR+hQWZ7KSfYuizqu0yg&#10;2R8/RunYeeDzEMJs3Q480T1lDPXXHAb+HngdTaPexoMfKpNbzygwFEIoBrU5xOj7dTR0Ll3LCMpU&#10;pHt8s0hTqC8hIfH/oE3xNPUZ1rZC2Xs1iw5pOUR/06T0KzSs1DARhT0+OG2YSWR1vZX8SvXMvZHW&#10;zmvAZ2hC9p/Ruu1yp4ZiUdEgepq4r6MDT0o3fo2Excsoar2PcrH2gn0zk6jvYI3SO/+TEMKNugiL&#10;eJCZRBmql1H25SeouXmSzYlSF2j9qGS+QBQWN1CzX5rK3EH/3t2Uk74f5NoCpUD/APhvSFCcol4R&#10;thVUFnkEZVsepf+lYvfCGvos/4RET6OIwn4Yie7GOsptNj1214+ifoocBLDZGMnG+gpyyPt9fH2F&#10;RMZqjdZPswEsKhpIT9ZiGdVRX0RZi89R9OcwOjjvxi5R6xlCG9mL6LOZQpOjPwkhXM653CWKiQl0&#10;/U+h4Yg/BV5CE6i3bOJfl/6uISqq0Y9lf7NINHdQac9FdG+noVmT3N86l6xOP0YZirdQLfA56udQ&#10;soo28mMow3KDPJpf00TyE+Q9PPB+GUU9P1vQ575U7eXUhgm0N+1kcMM1zebSO8fnDbR2HgFmm9Cn&#10;aG6PRUVDiYee5BB1Cm3ex1G0+iQ6HD1PadnnaFBJmhb9MioVmkYZnvdCCGeA+ZwOlTGyN4Ku9SAq&#10;dfsBZdnbNJtf7pYsH/vVw3BP9PQTfYqyCidQQ/ozyG42RTuTQ1TvmreGxMMaOuAuxddc/H9dQP0T&#10;f0COUzN13BBjkGEB9aGcRGvBfqpf/y+gTNMszXR+GkV9PgeBxRDCeTek3hNT6HPbh3sp6kbqnziK&#10;hMS/of6Jc9Qru2vuk6o3FdNnesTFdRQNvExZEvUK6h9Ik5THcb9FokAH5qdR1Gw/2uTeAI7Ez3Ot&#10;ykUylleMosP9HtQv8QrqnUg9NOk73Ww6SKxsoSw1qipj0Y2lUMfQQfUTJCZeRE3ph5Ao3Is+qw7K&#10;4i0jEbGAMnoXUHnQ6fj6Bm2OF9CGWOfylVW02X+DyrmepvzeBk0gOqwh0dZE++aUyTuExP0q8G4I&#10;4WLN76NBMImE2NNsbnbV9IcUmEm9W+8gd7y3cblT67CoaAk9/RbJq/4yiup+iQ6hL6Ma/O0o4u17&#10;o+wb2AX8AlmYPoamf74PXAohDNy1Jh5Yhigjes+hw/P3UNnTIfQ99rO0bQjdJ8nysdISuthjsYQ2&#10;tuvo/j6OfND3IZFxAImKdKhNsxGW0GZ4Lr4uoej5DeLAuAZsiMkC+Gx83eC7mZtBXstR5ATzBZll&#10;/h6U+HwOo2fzNTRoch+6394IITTq37tZxM9tBGUWd+PseR1IZgvnUMDiM1Qu+i7KjM7VMbtr7h8f&#10;HFtGPAAvhBBSv8Ul9PB/joTFYVQ2sh1nLBId9Hmk2Q4PA4+jQ9GxWH6zNIjShhDCMNp0U5nTD5Gg&#10;OBB/fStlr0M/SZHYKfJo+v02K4cycyvo4Jyyctvja4JyivNq/PEaEhk3UOnTUvy9blMOfz2i6xjl&#10;4MBX0eFt0PtAoBR9Z2hYliIyjtaJQ0jQ7kX/3m/QmtEEobrZpOzwM+jedOlTvqR1cw71SryDzCw+&#10;RwGD82hPdFauZVhUtJRYi76AopYpSjuD0s0HefA5Bk1kCyox2omyOk+gEo4jwIUQwiXg+mZFZnoy&#10;EqPo+9iJypweQ1mJw0gI7mPwcwcCKhtK0cXKRUUv8cC2Gl8LIYSraL1La17aFNPBrguEJh/04jN/&#10;GpUl7ESCYiq+BkVA5RAfo9KIGw38zDvoOX0aPatT8ec/Qz0ty/G9iWLqQUiudYfQOutMRb6kQaBf&#10;oWbsvyBBcQEJDZc7tRSLihazrpn7CmrgXMF9FXcilUOloYKHKaMznwAn4gF2AR0eVtGBFdZFvpOH&#10;PeWBPFmgJivKCZR52IuyRy+iQ8ohJCR2IKFTxXe1ipyWkrDImp7yv9Wen7eOoijmQggnUFTxCZS9&#10;Ochgsk0rKEPxAZr38Rnls9EkxtAz+gJ6XifQM/oKKqubQett42x0H5AOKjF9CH2G2a8rLWMN7WnJ&#10;Ze89ZAf9N7T/XaMZpaLmAbCoaDk90fBdKDr0JIqseUG/PR3K8oadyLL1CjoknUZuW5+g0o6rlPX7&#10;S7HsbA19vkPxlQbJjaDNdAId9h5GpRNPoYzEs/H3Ui18leIvRfqJ11CLjcQbHqDD7IfoPlpDtsOP&#10;o3urX8/9Kurh+iMagvU+DcxS9JQnPooOx0lQFCgz9BLKbH4eQlgsisI2s3y7D42hz+cFlJn1HpQP&#10;yejhKOqD+gLtcZ+jaod5GlQuau4fiwrTQQv4s6g+/ykU/faCfmdS2c8IEmGpuXCR0mXnBuVU82Sb&#10;OULZTLyEDuMddPjYicTdLlQusTe+p1/fOpB/2b2RhNUUOgx4M6kPK6hM4V1KB6gRlLnox57QRUL7&#10;fwH/N4psXmioveoYEhPPoCzFtp7f66AM4+vo85hHfRam3IcOonXP85PyIM3ruYBKFv+KMo3HUbYi&#10;9RN6/TeARUWr6YkOPQp8H6Xn7bpxf6SyKNDB4fH440to8Z2PPx9DYuIa5TCs3lKn6fi+FYm7UQbf&#10;L3EvdFD98zS6dlMTepq2z6ED/hjlkMd9bN6+0EXlEleBPwP/HdVfN1JQRIvnaRSgOYzME9bPcZlE&#10;/VC/A46HEK6gPqy2H8om0D70BAqiuPy2elZR8Os4yiy+Gd+PIzGx4kZssx6LinaThry9hETFIey4&#10;sRkku1fQQe0Rbt4k03yEZD05wneFQ+5RuuT+NI0OSkM0c4BZI+kRFqeRc0sqhXoFRYq3UM44ud97&#10;8Toq9fkI+G+ombORgiIygoIyL6Im7e23+DPD6ND8CmrcPg98EkJo7WCwHjH2PSTIdt35vzB9ZhmJ&#10;hovcLCg+Q/frfIOfYfOAWFS0m3F04H0Npetdx7r53CriNkqZDUrN2XWjQPdPyqyM2CazXkRhsYwO&#10;/jOoVO8DZFX8DGUj9wiluOi9V0PPe7fnlSaUfwz8X8D/QP0UTT+MjCFR8ShaS2+XYRxGZY2/QY3r&#10;14CTIYS2lpGMUbplHcCZzypIz+4y6pH4G3KJ+wTZUF9EQQKv8eaOWFS0lNhQuBMt5IewoBgkdRUS&#10;vRRIHE2he2cc1d56w6kRPa5YF9Ah4jgqUXoa+AEyCHiIsiQv1bp3UW9Gmkh+DdVdJ6OC00isfAac&#10;bElD8k4kxh5H2bvbPeOp7PQ5JCwuAX9Axg6L/b/MfIhZiikU3HqWm3tQzGBYRc/vadSI/Snqt0qZ&#10;iTlc6mTuEYuKFhJ7KbahSORryPEppyZgkz+pdGsrimZPomi3N54aEjMI10IIN9Dh9hjyoH8TNc8e&#10;iu8j6OCbLJPTAKyLSEx8gyKdqYlzseHZCQBCCCPo8zmMMhV3i7anxuQXkaiYB/4aQjhbFMVyP681&#10;M4aQaH0JCbJBzkxpOykwcBG5wb2LsotHkMC4Aiw7M2E2gkVFy4iCYgTVTb+EopH3sgkas55UC70X&#10;uV+dq/ZyzIMSBzeuxsGY5ykH5R0C9sc/NodERbJGXkbuZlfi+xKw1pbDSIy270KZh5fij+/V7GIP&#10;ct2bi6/FEMKFNnx2cS+aRp/bjyjnpZj+E5A74SkkKP6ASp5OoGd4GVvEmvvAoqJ9FCga9ARqFnwK&#10;RZmN2SjpULAf1ZLn6FJl7oOiKLqx3wKUeThP+f32Nm+neSVrtGAq+W0YRevoa2hdXe/4dCeS69FP&#10;UWZnFk2Ab7QjVBQU4+hz+wnaizwfaXAElKF4G/U8vY2yE4u08xk2m4RFRYvoyVLsB15Fm+AOfBg0&#10;988YKuOYxjaQjaLnYJFEw0r6vZ5p8K0eKBhCGEIlgM+gnoA9bHw9TcLil6i+vYscuZrchzKMmrJ/&#10;BfyczbUyNncnufeNUmYal9w3YR4UP8TtooNKGV5F6WZbyJoHZQgJizEsKlpDm4XEOlIp6TPokHw/&#10;M346SJh8L/54DZgJIRwFGmc1G4XYLjQE8NdIjG0ku2MenAIFFJ9E2bW/Ud57xtw3FhXtYgxlKV6m&#10;dNrwQdA8CMOojGECryemRcRsTRIDL6Asxf0yjA55L1BOMf5/gSMhhLmGRZC3As+jAYCHseNTVUyg&#10;PpZnUbP8BXqykcbcDz4EtITYTLgV2R0+jjIWLnsyD0Iqp0uTwMdDCJ2GHYCMuR2jwMOoJ+B5bj3s&#10;biOkfrfDKACU3LWOhhDm656xiCJsAkXGf40+t71VXpNhEtn5PoLsZOeqvRxTdxylbg/jqG71WVS/&#10;a+s+sxkMo+nLvZO1jWkDW9E8j9dRpHczmowL9Bw9Bfxd/H8fRIK9tk3M8drHgMdQH8XvkCBzYLNa&#10;xtH38DSwJ4QwWuf7zFSPH+gWELMUaS7Fy6j21zWsZjPooOhjmqw9jFPopuHEg9dOVJO+m83tTUsZ&#10;i9dQpmIM+CNlKVStMhZx/5lA+84vkFh6FgUjTLWMoLK9V9D07AvIGtq9Fea+sKhoB8OoMe4ZlKbf&#10;ibNUZvMYQ6Uf2/CaYtrBJIq6v0B/nM/SULjX0eF7G/B74MsQwtW6DBSM4msSBbR+hDIUr2K3uFzo&#10;oLX7ZeB94GtgNoTgGRXmvvABoOH01LHuR6JiH85SmM1lDB0SdmA3MdNgemy5DwHfR4exftlyd1DP&#10;wY/i37ETCYsPQwjnyXzaccxQTKLSmt+isqdX0L/JgiIfxlBJ9PeQC9QplG3O9t4y+WJR0WDiBjiM&#10;0vNPosjaCFosXDdpNotRdOjZgwWraTZD6HD/QzRf4Qnuz0Z2IyS3pN3o8PfvwJ+BE3HyeVZR5bjv&#10;pPkdz6Jyp39FQa2tuO8qR4ZQedqjwGeoYduGG2bDWFQ0m5SleAx4CW2A41hQmM1lFJXXPYzuN2Oa&#10;yhgK0PwUZSkm6X/UPa3jB5Br0j7k1vMfwOfA1RDCag4lUT2Z8QPoM/ot8AN0WJ3Ee0+udCgbtj8B&#10;LocQ1nISq6YeWFQ0mw6KID8PvIjSzv2Oqpn2kRygtuFMhWkoIYQ06O511EQ96DKeYZQN3ILq4B8C&#10;3gA+Bs6EEGbRsLyBi4s40G4cBReeRkLiF6jc6WFc7pQ7Bbq3XkR9FceBRdywbTaIRUWzScPunkGR&#10;rQkcKTKbTwdlK8aQ9eVwURSrFV+TMZtGjMBPo0PXr9Gsn6oCNJPAc+gQ+BjwNhIWJ5G4uILKV1b7&#10;HWmOfRPjKHh1AAWwXgd+jPYcD1itB8kh8lnUSP82cBUNYTTmnrGoaCghhGG0CT6GhMVkpRdkmkwH&#10;CYrJ+BoFLCpMkxhGJTy/QWVPDzro7kFJWYufoqbx14AjwBeoJOob4FoIYQ49i2uoRn7D/Rfr5hYU&#10;6HkfQs/5NJqjkZwFDyPBkwxBHMSqD6OUs6weAb4JISy6BMpsBIuK5pKG2ryABintwAu86R8jKNI1&#10;jQ4T89VejjGbQzxUb0XuOD9DDdM5RN+HUCnUIVQKdRg4g0pXTsXXJ8A5YAa4ASyEEHrLWtKecLuD&#10;Y4dSRAyjfWUalX49hqLaP4h//zSar7EFl9nWlXEkVh8HPgVm8dwhswEsKhpIz7C7p1AE6yBe5E1/&#10;GaYUFeMVX4sxm0kHRW5fRFnfnNbSNKk62TrvRIf962iI2QlUxnIm/vgKsIzKo67G13L8/6x3ZQrx&#10;1yaQqJpGB86D6PN4HPVPPI57qZpCh7LCYS9wHosKswEsKprJMNpcnkZOJduqvRzTApKF5A7sAGUa&#10;QgzQbEeC4jC6x3PIUtyOccqG6YMou7IKXEKZi1lUBnUNCY3L8fdH46/fiO/JjjyJle3o2d6FDpu7&#10;4q+lckfTHCZRqd9+4Fic4m57WXNPWFQ0jJiqH0ML/+NIUNgX3PSbIVT6sB2LCtMcJlCPwOuoZ2CK&#10;vEVFIg3pG0YZhylUJpXKnG6gbEZAImQs/toZlLkYQWVMU/E1EX8tlUMVPS/TLMaQIH0S+BIJz+VK&#10;r8jUBouKZrIVpaefxN7gZjCk6bk7gC0hhI6jW6bOhBBGkaPRr1BD9EHqF6C53cF/Gu0TUIqErSgD&#10;kYaj9vZT1EFImc1hHJU/vYaa/o+HEFbcsG3uBYuK5jFMae+3G6emzWDooIjmw8TJ2nYOMTVnEvWl&#10;/TS+59RL8aAkwdBL6p8w7WYIVTg8iYT0JMpieS03d8XRhwYR63+3IEFxCJWi1C2yZupJuvceQfef&#10;M2SmtkRL7v3AL5GDnvvSTJsYQcGhfXjWiNkAvlGaRYEWgEeRqHA/hRkUBcqK7UX2khYVps7sBL4P&#10;/A7d08a0iXSW2IfExei6eSXG3BKLimaR0pYPoYVgHB/szODooPK7SVQK5XvP1I4QwhByevonbJdq&#10;2kmBSuH2o+xzXQwKTMX4JmkIPaVP+1GmYhf+fs1gSdmKZEHpLJmpFTEauw3ZcT+HBLLXHGDV2QAA&#10;IABJREFUUdM2knvYXnSe2EmzeopMn/Bi2RxSluIZtCHuxN+vGTyjSFB4EzJ1ZARlJ55FByqbmZi2&#10;0kHr+CFkwDHuEihzN3zobA6jqOTpJeTa4PITM2hSpmI7ypSNxwyaMdkTy562A6+i5uxpvIaadpOG&#10;6D6NzxTmHvCG3xzGUOnTk+hA54ffVMEIypjtxkYBpl5MognUr6NMxQReR027mUbVD4eRVb3Xc3NH&#10;LCoaQIwGp4F30/jBN9UxTDlEaweek2JqQAhhhNJC9nVU7mFBYdpOr6PkTryem7tgUdEMRlBk+Nn4&#10;7lp2UwUFEhUTSNxOoyF4XmdM7mxF6+ffo54K91IYI8ZQafUu5ChpzG3xZt8MJpCN7CPYdcdUS3Ih&#10;24XuySl8P5qMiVmKp5CgeAmVQRljxAil+cYWB4nMnfDNUXN6Sp8ewlkKUz0Fuh8PAo+hEihHfU2W&#10;xPVzH/Ab4F/w5Gxj1jOEgkO7kOB2kMjcFouKGhPt3YZRBOEJ1KS9pdKLMkYbzwFkRbgdC12TL6Mo&#10;Q/FfUB+FD0zG3EyBzhUPoyCR13NzWywq6k8HRRF2ogff36mpmiHK7Nk2nKkwGRJCGEV9FD9AAZkR&#10;3JxtzK0YoayG8LwKc1t8AK0/I0hUbAVCfBlTNaNI6E5jxxCTGbHsaTfwYzyTwpi7MYSelx2ocduY&#10;W2JRUW8K1KS9Bz3wTt2bXBhGpU/bcWTLZES8F6fRTIqf4LJRY+5GBz0z27EDlLkDFhX1pkAP+aPI&#10;+WkcR9tMHgxTDsGzA5TJiTHU7/Nz4PvoHvW6acztSdPm03rus6O5Jb4xakqMto0Ce5F7yVZ8cDP5&#10;kBxD9hCbtZ2tMFUTQhhGteGvoUF3j+JyDmPuRspUPIzOHJ4/ZG6Jb4r6kkqf9iGnnW042mbyoUCZ&#10;s714aJLJgBDCEDoYvQD8NL5P4XXTmLuR5g/tR8JiEp8fzS3wTVFfOuigtgtFg7fi79PkxTC6P3ej&#10;DcmHN1MJMUs2gaZl/wT4Ibo3nd015u4UKKO3m7IywucN8x18U9SXNKNiDJVBeXM0udFBpU97UYTY&#10;642pilFU9vRj1EvxJLY6NmYjJKvwnbjc2twGb/L1JUUOtiBbWVvJmtwYQlm0Z9B07TH3VZhBE++5&#10;7cDLwG+B53DmzJiNUqCyp91IWFhUmO9gUVFfRtBGuT++G5MbHbT5PIfsO+0aYqog9VH8DngVlT1Z&#10;UBizcbYgUbEXWYV7PTc34RuihsTI2xhK5z+CRIU3SZMbqY79UeBpNDjJJSdmYIQQxoAnkNPTL1AQ&#10;xvegMffHGBLlD+MSKHMLLCrqyzhyfdqDDm4WFSZH0qCx/ZRWhL5XTd8JIYygNfJ1JCoO4enuxtwv&#10;BaqQ2ElZITFS6RWZ7LCoqCdpBsABFP31g21yZgzdp7vjjy0qTF+J9rE7gZ8Bf4/Knxx8MebBGKac&#10;V7ETi3SzDouKepLsZLehximn803OpPkAaZ6KU+amb8RMWBIU/4gG3bmx1JgHZwidOfagMqgJ91WY&#10;Xnwz1JNhFHUbx1kKUw+m0YyAPXiCsekvU8CLwP+GhMXDOPBizGaQ+uR2o57OrfjZMj1YVNSTEbRx&#10;TuEH2tSDKdSs/STKVhizqYQQithH8SQqefo7ZBLgEg1jNo/UrH0Ql1+bdVhU1Iwe56edqJxkotor&#10;MuaeSKLi+8DBePgzZjMZQmYAvwT+Kzr4eI8zZnPpoMDQQfSMWbSbb/GCWz+SA8MU0Su62ssx5p4Y&#10;BfYBryCLzym7QJnNIjZm70CzKP4Z3WMWrsb0h1F0/tiFzyCmB4uKepJExQh2MzH1IE1jPYQyFg/h&#10;xlmzeUygidn/hLJhdnoypn8Mo2qJPThAZHqwqKgfBRIUO+LPQ4XXYsxGSBO2XwSeBbbYOcQ8KCGE&#10;cWQC8I/AD9A9ZozpHykzuD++D1tYGLCoqCPDaOjMfmAL/g5NfeigbMUrwA9RlMvZCnPfxN6cQ6js&#10;6R9Qn5kxpr8Mob6KA6is1ZlBA/hAWitiJGCYMlMxhQ9lpl4MA48Bh1F02fW45r6IWa49wI+B/4zu&#10;K9sVG9N/krXsw0hYTOOziMGioo50KCMCfohN3ShQk98B1FsxHUKwLbLZEFFQbEVZr98ikTpV6UUZ&#10;0x7SOv4oZY/ciEugjEVF/ShQH8Uq0K34Woy5X3agvor9OLpsNkA8uIwjh6dfAa+jPgrvZ8YMjiFU&#10;+vQUspf1Om68CNeQDiohsV2iqTPTwDPx5WF4ZiMMIzvLn8fXY3gvM2bQ9JZAPRJ/7Oew5fgGqBep&#10;p2IbivQ61WjqyiSafPxjNAzPA5TMXYllTzuBV1Fj9rMoQuq10JhqmEblrFtxSXbrsaioF2nw3Q6U&#10;dvRBzNSVURTh+jHwPdRb4fXI3I1pNI/iv6B+ih13/uPGmD4zRZxXgUVF6/EmXi8CylSMx5e/P1NX&#10;0jC8x1EJ1EPo3jbmlsR5FE8Dv0G9FA/hNdCYqtmCRMU0LstuPV6Q60VA31kXWMCD70y96aA63KfQ&#10;YXG7naDMekIIRRQUj6Eeil8h1xkfYIypnnFgFxIW43aAajcWFfUilT91kPuTRYWpO2PA94FfA8+h&#10;KdvelEwvo6gR9O+BfwJewILCmFwYQQN59+ESqNZjUVEvOigqsAVttD58mbozhA6MrwIvos3Jm5IB&#10;IDbwPwn8n8B/BV5CDaFe+4zJgw4qZd2FRUXrsaioCTF6O4QExU70APvhNXUnzRx4BImKJ4CtzlaY&#10;EMIQ8r//FfCvKKO1CwsKY3JjDJ1LpnAWsdW4frleDKEHdiuK6FoUmqawA4mK48BlYBH1DZkWEgXF&#10;LuCHwH8CnkfrnjEmP0bQ87odu1K2GouKepF6KLrAWpUXYswmM4VmDiwAJ4FLIYTFoijcN9QyoqCY&#10;Rpaxv0MTs7dUelHGmDsxitzYHkLP6pVqL8dUhSPd9SJQljwt40Zt0xyGUJTrKdSIewA7ibSVLege&#10;+FdU+rQTl3oakzMjwG60bu+0i1978RdfPzpITFhUmKYxjGwJfw1cAmaBEyGEZWcs2kEIYQJZx/4G&#10;+BmyjvU+ZUzeDKPs4h5gGzASQljzut0+vFjXi4JSVNhS1jSNNBDvVeAicBqYBy4gEW0aSpymPokE&#10;xS+A36KmfddnG5M/aebQNGWz9hI+o7QOlz/Vi+QANYy+O5eGmKaR3KCeRYfLl1A63Y4iDaWnh+IF&#10;4B+AfwYO48ZsY+pCWre3oed2DJ9PWokzFfUiWcruiC+LQtNECuBxNOwMlKX4IIRwpSiKbnWXZTab&#10;mKHYipy//gWVvh3CsyiMqRNpMO8UEhbj+PltJRYV9aGIry7lA+yH1jSVMTS74kfISWQJ+Bi4VuVF&#10;mc0jNnNOA08jl6ffoqnqY7gx25i6kQIE0yj46fNJC7GoqBeB0r+/izde02zGUF39b+LPh0IIHwDX&#10;i6KwpXKNiSVPe5CIeB0JiqexdawxdSX1xG2P766kaCEWFfUhoNkUS0hYLKPvz9EA01SGkZ3oK2iT&#10;GkX3/2chhOsuhaonsT9mO/Aa8HcoG/UC7qEwps4UKCgwTRQVIYTCDlDtwqKiXgT04CZL2QksKkyz&#10;Sa5A30MZugvAHHA8hDBnYVEvoqDYhYTiv6Cyp4fwWmZM3ekVFVvx+bKV+EuvFwEdsrp4ToVpDx20&#10;WT2DDqErqPTvWAjhhkuh6kEIIZWz/QMqaXsF2I/6w4wx9SY5QCVRMYLWbq/PLcKiol54ToVpMztQ&#10;ycwQchh5A5VCXS6KYrXSKzO3JTZk70XZpp8iUXEYHT6MMc2gQH1wW+NrHLiORUWrsKioF2lOxSh2&#10;fzLtI03c/gmwO/54K/B+COEisOT63XwIISSXul1ITPwT+u72I+tJY0xzSM/7JKWtrJu1W4ZFRb0o&#10;kKBItm12fzJtI/VYvIA2rj0og/E2cDKEMO8+i+qJ8yfGUYbiZeA/A79CNsFD+LBhTBMZRqWqKVPh&#10;wGfLsKioH8sonejvzrSVDkqzP4o2sH3xx38APgkhXLWwqI6YoRhH/ROvAz9HmYpHcP+EMU2mQGeT&#10;ERz0bCU+mNaLgBxw5pGw8ENr2swo8DAqpdkRf/x74O0QwtmiKJYqvLZW0jMh+zE0Hfuf0fyJfVhQ&#10;GNMGRlDQx+fLFuIvvV50kaC4jvz63Vdh2k6ByqBeQqVQD6Ma/j+GEL4B5u0O1X/iMLtRJO4OAz9A&#10;ouKnuAzCmDaRmrXdU9FCLCpqQlEUIYSwRikqFlDph7MVxkhgH0AC4+H4/ifgSAjhKrDiJu7Np6cZ&#10;ezv63J8D/nfgVTR/woLCmHaxBQUXpvD5pHVYVNSLNJ9iDriBHlw/tMaIDhITLyIjg2eA/0BN3KdD&#10;CIsWFptDFBNDKCq5B4mIH6HP/pX4a6NYUBjTNtKsiil8xmwd/sLrRUC9FAtIVPiAZMzNFGgzexoJ&#10;jIdQPf+fga9CCDNu4t4UxlCZ2UHgedSM/UOUrZjG/RPGtJVRlK0YA0ZCCIWDOe3BoqJepKF3c6gE&#10;yocjY27NMCqHmgJ2InHxB+CjEML5oiiWq7y4uhJCSAeGQyg78RoScM+gz3usuqszxmTACDBB2azt&#10;qdotwqKifiwDs8A1/KAaczem0cH3IWRp+u/AmyGEM0icrzmKdntimVMHHRS2okzEAdSI/Vvg++gA&#10;0cFNmcYYZYvHUUDHJZAtw6KifvSKCmcqjLk7Y0hQbEPzLJ5F1rMfApdDCCtAsLgouYWYOIhcnV5H&#10;8ycOosnYk1hMGGNuZhyVR9qooWVYVNSPVeQANR9/bIy5M2kS/W4UVd+D5ij8G/AecAa4EUJYsP3s&#10;t4ygLM/DqLTpMCp3egkZRIzFP2NBYYxZzxhaJ2x73zIsKupHF4mJlfgK+KE15l5ITdxPoT6LXcCT&#10;wGdIWHwTQrgA3GibuIiZiWGUediNPpcXUe/EY/F9P/rcLCSMMXdiFNlM27ChZVhU1I9AKSyW449t&#10;K2vMvTOEDs4/R4flY8ApVA71IXA8hHANuaytNFVgrCtxmkIZnEeRm9NP4msnijp2cPDCGHPvpCZt&#10;0yIsKmpEzwC8RWQpO4+atS0qjNkYBTosP4b6AxZRec/7wAfAV8A3wPkQwhzKCnaRqK9l/0UUEaB/&#10;+xASE1uAvajE6VXUb5J6Jnbh8gVjzMZYQ+eTKyj4aWHRIiwq6kcXHYBm0IO7ilKNxpiNkaZBJwvE&#10;cZTBeAk4h4TF+8Bx4CpwGT17SyGEJUqjhGxFRhQSKSMxjNaKSdS0nuZMpJ6Jl+KvTcY/5/3BGHM/&#10;pOCnzWRahjeN+tFFZRkzaFaFm7WN2RwmUN/AXjR74TngZSQwziCRMQ9ciD+fQZvnfAhhEehWOf9i&#10;XSYiiYhhygm3+5Ed7D70b9yLGrH3x/fdOOtpjHkwhtD6Y0HRQiwq6kcAlpCl7CwWFcZsJkPxNYas&#10;VB9DvUuXUMZiCTgNHEXZixXUj3EBWI0ZjHkUpVuMfz6l/1eA5d6sxt2mzYYQUi9DEgzpz6bG6uF4&#10;vamkaTS+xpFImkQNkwdR4/XTSEDsiP++LbjEyRizuaTghNeVlmFRUU+WkKCYQQcVY8zmk8TAOIrm&#10;P4QO9bMoS5g2zE+RyAjxv7mIMhnnkfCYQOL/EnAphJCyGQHoxjkZ3fjfJlGzvmyp99eGkRCYRKIg&#10;TbEeR0Jhuue1DQmI/cjRaVf88+n/Dd74jTGbS1rLvLa0DIuKerKCDjWzSGAYY/pHygKk6NsuFP1P&#10;G+ZONFk6/fwqejZX0Oa6BQmML5GwmEDP7TmU9ZhFa/EOytKkFdTDkX5vPP5/kkjYRdlIPYcCDEPI&#10;xWkaiYtJyl6R9LLFozGm3wyjtWgYC4tWYVFRM6ID1Apq0p6lbIayw4Ixg6HDzc9bygokdqHMRMoq&#10;DKGD/7PoeR1FouJqfK1ROjFtQ5vxMhIKi/H3xijLmrb0vIr4Zxbi3z0S/9wIZXmUN3VjzCAZRWui&#10;gxgtw6KinqSp2jPosGIHKGPyIR3me5mMr8RafMGtexrS7ydhcidhMI4yJ8YYUzUBrV1dShtu0xIs&#10;KupJspWdRRmLZSwqjKkTveVU9/P7xhiTI2lORbLgtqhoES6ZqSddVD4xg4RFZTaWxhhjjDGRgtL6&#10;PuDyy1ZhUVFfVigdoBYrvhZjjDHGmGSD7dKnFmJRUUOir/0ySi9eRH0VxhhjjDFVktzy1s/WMS3A&#10;oqK+pIFcp1G2wg+uMcYYY6pmvUOeaQn+0uvLGhITZ4ErlE4yxhhjjDFVUSBXu4ADnq3CoqK+BNQI&#10;lQZtLeOH1xhjjDHVsYrcn5IzZbfayzGDxKKiphRF0eXmZu3ktGCMMcYYUwVpOO9ldC6xqGgRFhX1&#10;ZhW4jsqfbmBRYYwxxphqSZb3SzEAalqCRUW96aIH9zwSFn54jTHGGFMVw8j9aQkghOA5FS3CoqLe&#10;BJShuICcoCwqjDHGGFMVI5RN2uDhd63CoqLeBBQNuIxFhTHGGGOqZRHNzlrB7k+tw6Ki/qwgB6hL&#10;qMfCGGOMMaYKbqDzyDywEof1mpZgUVFj4sO6ivopzmIHKGOMMcZUxwLq9UzZCtMiLCrqzxpwDTiD&#10;eisWsbAwxhhjzOApUCn2Ei7Jbh0WFfUnoIjACeB94CIugzLGGGPM4BmNr7WqL8QMHouKmhNLoJaA&#10;c8DH8X250osyxhhjTNsIKDuxRtmobVqERUUzWEUlUCeQqFio9nKMMcYY0zK6lAN5l7CoaB0WFQ0g&#10;ZivmgFPxdb3aKzLGGGNMC7kMnERnEpdAtQyLiuawhBq1TyDnBWOMMcaYQdFBVrIzqAzbmYqWYVHR&#10;HNbQg3wKlUIZY4wxxgyKVRTgXMA9Fa3EoqI5dNGDfBZlLBawnZsxxhhj+k8XlTz1zqiwqGgZFhXN&#10;Yhk1an+NahqdfjTGGGNMvwlIUJxHjdrLnqbdPiwqGkJ8eFeAS8AnwKfADZytMMYYY0x/SXay11EJ&#10;tpu0W4hFRbPoIiFxAjiKH2xjjDHG9J8kKhawrX1rsahoEDFbsYyman+Dshaerm2MMcaYfpLMYmZQ&#10;s7ZpIRYVDaMoijXgKhIVp1FJlDHGGGNMP0jl1ydRT4X7OVuKRUUzmQPOAMeBxWovxRhjjDENJqCz&#10;xllUIWFR0VIsKprJMrKV/RwJi/lKr8YYY4wxTWUZZShOoonadn5qKRYVzWQNWbp9DryPHnY3bBtj&#10;jDFms1lFZ44LwCwuu24tFhUNJEYI5lFfxfuUMyuMMcYYYzaTgITFHLDoLEV7sahoKEVRrKCG7a+Q&#10;qJjDNY7GGGOM2VwCqoZYxo6TrcaiotksIQeok2hmhTHGGGPMZpEG3p0m9lNUezmmSiwqmk3qrfgC&#10;ZSxm8IRtY4wxxmwOAQ3dPU7p/GRaikVFs0kRhM+Bd1GPhRuojDHGGLMZLKPgZaqI8BmjxVhUNJjY&#10;LLWExMTHwBEcRTDGGGPM5jCDshRngAXcu9lqLCqaT6B86I/iYXjGGGOM2RzmUdnTFez81HosKhpO&#10;T7biPBIVV7E7gzHGGGMenDWUoZjDZ4vWY1HRDtZQreNR4EsUUfAwPGOMMcbcL6uob/MKatb2uaLl&#10;DFd9Aab/FEURQghzwDHgT8AuYALYWumFGWOMMaaOJNenkyhgOYtFRetxpqIlFEWxDJwD3gE+Q5kL&#10;1z4aY4wxZqOkKdoXgVPAkvspjEVFu5hHEYVPkVPDChYWxhhjjNkYq8AF4ER8dz+FsahoGWkY3qfI&#10;YvY8HoZnjDHGmI3RRXb1x5HDpEufjEVFywjIpeFL4C1UBuW5FcYYY4y5VwKqdDgFnEbnCgcojUVF&#10;m4j1jisoQ/ERylbM4xIoY4wxxtwbK6hH8xvUU+HgpAEsKlpHFBYLKMLwCXKEmsPCwhhjjDF3JiCn&#10;p8+Br1FJ9aqbtA1YVLSVLhqC9wXwNnAWRR6MMcYYY27HCpqg/RkKSs5YUJiERUUL6clWnADeQIuD&#10;B+IZY4wx5k4sIVFxDJVSL1Z7OSYnPPyupRRFsRZCuAJ8ABxAg/BGgR1AUeW1GWOMMSY7AhIRl5Gg&#10;uF4UhYOR5lssKtrNInJueBt4KL6mgaEqL8oYY4wx2bGGshRfoUnaC9VejskNlz+1mKIousB1yoF4&#10;p3EJlDHGGGO+S+rHPIpdn8wtsKgwq6if4ghq3L6Im7aNMcYYUxKQBf05lKW4jqdom3VYVBhQCvM4&#10;8A7wLnAND7IxxhhjjAioj+IoEhZLdn0y63FPRcspiiKEENaAC6hpez9wENgSX27aNsYYY9pNQFUN&#10;p1CjtkufzHewqDAURdENIcyjlOZbwKPAOPAYMFHhpRljjDGmWnobtI+gagb3X5rv4PInA3w7u2IW&#10;+BLNrvgc1Uw6vWmMMca0k9RLcQT4EJU/zeGzgbkFFhXmW4qiSJMyP0FuUOdwI5YxxhjTVroo4Pg5&#10;GpR7DlhxP4W5FRYVZj3LwBngI7SIXMVpTmOMMaaNdFFm4ijwDRp4Z0Fhbol7Ksx6uqhe8kNgF5qw&#10;/TPUtG2MMcaY9nAdlT59iSoZXL1gbotFhbmJ6Aa1hBwe3gb2AI8AjwOj2A3KGGOMaQNLqHLhfeAY&#10;cMNZCnMnLCrMd4jCYh7NrngTCYoJZDU7VOGlGWOMMWYwzAJfo8qFs8BitZdjcsc9FeZ2pDKoT4B/&#10;Q/0VN/BQPGOMMabpBNRTeTS+ZoqicOmTuSPOVJhbElOcKyGEy8B7aGbFVuB5YBsWpMYYY0wTCaj0&#10;6Rwqezoff27MHbGoMHcj9Vf8CRhDTVrPoQZu3z/G1IMu6odyT5Qx5m6sAReAL9DAOw+7M/eED4Xm&#10;jsRp2zfQ3IoOOpSMox6LqSqvzRhzV9ZQHfQyMAmMYGFhjLk9AVhAJU9p2N18URQufTZ3xaLC3JUo&#10;LK6ivoopYD9yhRpDhxRjTH50gRnk3nIDGS7swuu+Meb2rCEb2S/Rnn8B28iae8Sbi7kniqJY7REW&#10;f0L9FSPAARz5NCY3uuhg8DnqibqBMo1b0LNrjDG3Yg0FI44Ap4E528iae8WiwmyEZdS49Q46mKTh&#10;eBO4cduYnFhGVpB/BP4CrKDypyngCVTCaIwx67kK/A34CGUp3Eth7hmLCnPPxDKoOeAEEhapDOpJ&#10;JCycsTCmelaQp/z/396dPdlV13sff6+9e246ExkYQhgFDiAochSfc3xuPGWVWPVY5Y3/hTeWF97K&#10;n2CVVVrlpVX+AXrx1HNkEFFmAmHMQBIghCSdsaf0sNd6Lj5ruTeoB5J0p3vvfr+qdnWTENho77XW&#10;9/edXiJZxf0k6N8C7AS2ks+un1dJvWZJY/ZfSPnTjFkKXQmDCl2RnsDiMPA8sINun8Xoer43SZTA&#10;NDlp/AvwFhkH2SZNl7eR8dA34SJLSV0dMunxFZKlmCYHFNKXZlChK1YURaeqqnPkgWU7CSxa5EHF&#10;wEJaH83CyreA/0seDk4VRbFcVVWHlC6+AzwKPEJKoMxWSCpJ2dNBcvjwMZn4ZJZCV8SgQlelbtw+&#10;RR5cRkgN9zeAvaQZVNL1UZETxU/JCeMzwAtk6tPlnr9njiyy2k92zdxLyhYlbV4luTYcJhnOt4Gz&#10;OPFJV8GgQtdiAfiQPLA0zVyjwO3r9o6kzadDHgJeA54G/kr6nv5+0lgURVVVVdNrsR+4hwxa2INj&#10;oaXNrDlweB94g1w7FsxS6GoYVOiq1Q8q8ySwgJRTbOl5WbMtra0SuERGxz5fvw6SMZCfWVZV90Nd&#10;qn//BdJbMULKF70XSJvTMjmUOEjGyJ4ngYZ0xbyR6JrUDyoLpAbzBfKQ0iKlUDtIYGHdtrQ2mmkt&#10;z5HP31H+SUDRqPuhTpPdFbeQIQvjuLtC2owqcijxdv36FFgxS6GrZVCha1YHFvPkgaZFTk87pCF0&#10;D2YspLWwSD5zz9WvQ8ClfxVQ9GjKFl8nfRW3YVAhbUbNffuvOEJWq8CgQquiPgG9RJq9KpKxmCIL&#10;t6ZwOZ60mjrARyQ78TQ5ZTxXFMUXNlfWhwAz5GHifeB+sm9mGLOK0maxTIY5vEoOGD4lA1ekq2ZQ&#10;oVXTU7N9hPRX7Ky/foVuj4UPLdLVK0mm4RTZlP00aa6cLoriSmbKr5A59O+Qz+ceUg5lVlEafBXp&#10;nXiLXEeOkbJJsxS6JgYVWlV18/YsOQFtRs0ukhGW2/FnTroW88AHZLHdM2Sk8xmufPxj0+D9DslS&#10;7CKfz0kM/KVBVpF78hHgJTKG+iwuutMq8AFPq64uhbpIHliacbNt4KskYyHpylQkQP8QeBb4bzIa&#10;9hSwfKUnjHXwvwicIKUPe4CbyahZAwtpcK2QUqe36tcJ4LJZCq0GgwqtiXo53jngXRJQTJAdFveT&#10;iTOSvpwOcJFuD8WfSEDxaVEUV10DXZcrzpHSh5dJw/ZWUrLovUEaPB3gAunBepU0Z18imUvpmnnj&#10;0JrpCSzeIT9rJdnw+wB5eLF+W/qfNQHFO8CLZA/F68BpVqFcoQ4szpNyxVdI0L8b7w3SIJoj5ZMv&#10;kYOJk9dyMCF9njcOrak6sJgmpyIz5JRkHvgasA0nzkj/SkV3D8UzpOzpHVL/vLRa5QpFUSxXVXWm&#10;/mcfBPaSrKL3B2lwLNKd9vQSCS5m1/UdaeB409D10Jy2vktOVxfr18OklnsUAwup1wqZ8nSUTHh6&#10;hpQsnGVtllM1/64/kyziMOmxcBS01P9KMtDhANlJ8S5w0T4KrTaDCq25+sK1Uo+bPUT3gek88Bhw&#10;B+m5kNR9AHiHjHt8hjqguMKxsVeiQwKWV4EbSQnULjLBTVL/Ksmh3vukJ+tNMk7aaU9adQYVum56&#10;lm4dJr0VcyRDMUZKLnyA0WZXAudIvfNTdDfdXvgyi+2uVj0N6jKZLvUKcBMJKu4kmURJ/aci99pj&#10;ZBjDq2Tgg9OetCYMKnRdfW7iTAcYJ8FERcotxrEUSptPRTJ4zUKqp0kPxUFgpiiKNZ/OUgcWc+RE&#10;c4rsrdhKAgw/k1L/WSZjp18nQcVhYLYois66visNLIMKXXc9M/I/Jg9PF8np7H9x/ax4AAAWuklE&#10;QVSSUqhJrOXW5lGSHRQnSc3zn4HnSKngdQkoGvWOmfOk5no3mQY1ScZA+5mU+kdJBqM0k+OaIQ8G&#10;FFozBhVaFz3lFifICe0sCS4eJ9u3d+PpqAZf87P/MSlNeK7++iE5UVyP+fHN6eYrwC3kIeQBMq1t&#10;CD+XUj+YJROeXiTllJ8Ai5Y9aS0ZVGjd9GQsTpJpUHMkYzEDPEpquh05q0HVlDu9S0oTXgTeIDf/&#10;hfUqUag/lwvAcdIk3mQovkoCCz+P0sa2SA7sXiPXlmPkkMKAQmvKoELrqr7ILdW7LBbJ6co8aS57&#10;hPRZTOCiPA2OivyMnyY1zs+Shuz3WeUdFFerp/fpPdLzdAMJKEbJ59HAQtqYOmS60wEy7eld4Pw6&#10;ZT21yRhUaEOol+RdJHXkS8AlcmF8jEyg2YJZC/W/igTPR8gJ4ivkNPEwKf8r1zugaNT9FRfIZ3IX&#10;2SkzCdyGE6GkjahD7p3NOOr95PBizSbHSb0MKrRh9JyOHiWlUNPkgvjvpKa7WZRnw6j61TIJKP5M&#10;RsYeIP0L8xtxIksdWJwls+1vIFOhtpCeJ0kbyxz5rD5Ngorj2Eeh68igQhtKHVjMk3rQeTK94jRZ&#10;BvYIsI+MubQcSv1kmfwsHwP+QnoV9pOAYt3Lnb5AU5/9Khkzu4vslpnCzKG0UTT7KJ4nAcUR1m/Y&#10;gzYpgwptOD19FmfI5u0LJKiYBr4B3EMebCzB0EZXktKDT8n+ib/Vr/fIz/TyBg8oejOIHwIvkb0V&#10;28i42eH1fG+SgFxjTpCSyr/RXZhpQKHryqBCG1bPBu6jdHssTgHfIpNo9pITU8uhtBF1SDnCSbJ8&#10;6llyw/+QDCRY2egBRaP+LM6Sh5XnSfnTDmAnaeQ2YyFdfxW5zpwm15hngLeBs0VR2Eeh686gQhta&#10;z9jZ0yRrcY6c+p4iTdz3kBpvf5a1UVQkQ9E8hD9FSp7eIT+7ixuxf+JLWCGfvzfoLsP7NtllMYaB&#10;hXQ9VWSoyQVSSvkMyVScqn9duu58ENOGV5/mLteTaBbJHouzJNBoluU1Tdw+2Gg9rZCfyw/J1KTX&#10;yf6JQ6QcYXkd39s16fkcfkrKoCry3/s4cDswvo5vT9pslskhxaskoPgrWaJ5uV8yoBo8BhXqG3V9&#10;6FxVVR+RspLzJLiYplsO1Yyela6nptTpNDk1fJn0UBwhy+zmBqi++TLwEQkqChJMTAC34gAF6Xoo&#10;yf3vLeBPJBN6lEyRM6DQujGoUN8pimK5XpY3Ty6sp0iT2iPAfaTeexx7LbT2mprmCySAeIP0HOwn&#10;p4az9EEz9pWo/1sWqqpqNvZuJ+VQw8CNuE9GWksV6TF8n1xrXgSOFkUxs67vSsKgQn2qnp8/R0bo&#10;XSTzuA+SJu7ehXktfMDR6qtI+cEC+fk7SE4LX6i/P01O9DfMMrs10GQs/kzKoC6TnTI3Y7ZQWgvN&#10;8sz3SK/Wc8AHJEsqrTuDCvWtupzkcj16dpaUQp0k9eyPAQ+TkqhWz0taDQuk3OA90i/xHmnEPkaC&#10;jIHKTvwzPTtljtJtTh8iWYsd6/nepAG1Qg4tniHT5N4HZgaotFJ9zqBCfa8enTdTT4m6RJrXjpMH&#10;vIdJOdQeUqbhz7yuxRIpuTtCshKvkKDiJAkm5jfTDb7OGM6SwKIFTJKA4iGypNJAXrp2HXKQcZJk&#10;J54D3gXOOzpWG4kPWBoYRVEsVVV1lmQtTpMHvzfJdKim32In9lvoyjQL7BZIwPo2mX70Ejk1PEvG&#10;xA50ZuJf6dlhcZTs4Zgi/5s9QJbkDWEJonS1mh6Ko2TS01OkQfucAYU2GoMKDZT6Aecyad6+SEqh&#10;DpLMxWPkBLXpt/BhR19khW6Q+hEJUl8hN/WBbMS+GvU+mVlSjlGQjM4S8DWSuXAqlHTlKrqlls8C&#10;T5NhEKfJtUnaUAwqNHDqB7yVupH7MtlrcYY0tL1DgouvkxGYY80fwwBDXU2PwDmSmXiR3MwPkxKE&#10;86RhcpAbsa9IXQp1ifSXtMhnazvJDE7i50u6EiW5xhwjOyieIlPlzgBLXne0ERlUaGA1wQVwqc5e&#10;nCOnzcdIBuNBEljsIWUao+vzTrXBzJLdEsdIluvN+nWMlCEsbqa+iStRFMVKVVUXScZihAQXl0kJ&#10;4nYsO5S+jGZM9UHSu/UMCShOF0XhtmxtWAYV2hR6+i2arMXHwAHgHvLAcy8ZhTlJxmFaGrV5lGQ8&#10;7CIJKJra5VfJw/HHJCB1U+2XUGcszpNA7DL533SOLKjcheNmpS9ykWRI/0R2UbwDTBdFsbyu70r6&#10;AgYV2jTquu8lsoF7lpw8v0ECi6+TzMVtpAZ8J9kSbC34YLtMbuBn6U4Ne4ssdTtCgolFoGNA8eXV&#10;GYvz5GFongQV88A3yDS2JoshKZpFmvPkMOOp+vUucKEois46vjfpSzGo0KZSPxh26vn6zQjaU6RW&#10;/iXgLpK1eLD+emP9R9v4EDQomn6JJZKV2E8CiSMkK3GKBBlzwIrBxNWpMxYzpJepWdo1RwL4fWSf&#10;hdlAKZZJA/YhslDyKRJcXDSgUL8wqNCm1NPM3aF7Wn2CXMTfJqdDD5EgYzdZotdMjFL/Kkmm6k1y&#10;in6A1C2fJDXM8yTYMJhYBT17LI7QLS+bA75LGrj9PEnp/ZsmJZfPkcEQ75NrkgGF+oYXdG1qTeaC&#10;jO1bqKrqAjktOk4eOm8H7iZL9O4lZVGjuOui33TKsry4vLx8fGVl5dXh4eFnhoaGDrRarY/xJHBN&#10;1U3ts1VVHSMBW4dulqJ3Apu0GTVT5t4kI2P/QrJ7M1h2qT5jUCH1qGvBL5DT1JNkPObNJHPxDdJ/&#10;sQu4iSz5GiX14W0cS7thVFXF0tJSZ2VlZbGqqosjIyMny7I8eP78+RcPHDjw/IULFw5t27Zt5nvf&#10;+54jYa+ToiguV1V1gpRCtUhW6NskcLd/SZtNUxJ4npRfNk3Zh4EZJ8ypHxlUSJ9TN3QvkxrXBVIa&#10;9QkJLPaRZu47gFvqv76VBBgj9cvJUeujAsqyLFeWl5cXT5w4cfG999774IMPPnhp9+7dz957770H&#10;t2/fPj03Nzf/1ltvLT/55JPetK+/JfJZep70M50D/jfJAm7Fe5I2h4qU3X4EvEy35OkoMGtAoX7l&#10;BVz6J3pOr3uX6F0g+y22kjKo3eSU9U6SzdhLAo7dpDxK19fiysrKh5cuXXr50qVLr50+ffrYxx9/&#10;fPoXv/jF6TNnzpwi5QTerNdR/blarKrqFKkjnyOBxX+Q7ds348hZDbYVMgjiIBkO8gIpfToBLBhQ&#10;qJ8ZVEhfoGeJ3gowX4/K/ITstHiPboBxJ9l58RW65VE7SIBRYg/GqquqaqUsy0+qqnqj1Wq93+l0&#10;jpw5c+bd3/3ud+8/+eST0+T/M20w9d6YMyRzMUuyFgvAo3T3xZjt0yApyc/4GZL1fo4EFIeAM0VR&#10;LK7je5NWhRdt6SpVVdUideBDpNl0J93G7n3k4egesrF7nGwUburG26RUSlfnMnCuLMujS0tLL12+&#10;fPmPs7Ozr//+978//7Of/cweiT5RVVWbBBC3Af9OMhZfJwG609Y0KEq6izUPAK/QDSguYUO2BoRB&#10;hXSNqqoqSBaiRRq3byABxE66JVF3kCzGWP33TdENNobpNnrrHzUTupqt1wukDO0vwH+vrKy8vbCw&#10;MD09Pb141113WTrQZ+rgfJQE4Q8C36pf99PdwG2WT/2qImV+H5DpTs+TseWfkP4Js6kaGD7ESKuo&#10;J8AYIg9KE/VrCthGdxztTpLF+CrwACmXarYM+7mMZkndZXID3k+aGj+o//pT6iV1joTtb/XnZpiU&#10;C95NyqAeBx4hWT+nQ6kfNdev48D/q19vkhKoJa9bGjSmlqVV1LP3okMaUmfoBgpNNmOYlHzcSCZH&#10;3Vp/v63+/iEScGy73u9/g2jmth8n5QHHSNnA4fo1XRTF/Lq9O626+nPT9Fk0yyinyc6Yb5A+pR1Y&#10;Mqj+cpJkJV4GniW7j84URbG0ru9KWiOeiEobQFVVQ6SG/A5SW/7Vqqr2VFW1DdhVFMWeoihuZPAm&#10;4zSjFWdI1mG6/vohaYJ/iwQUZ4HL1h0PvjprMUaGH9wHPEayFv9GMnoTWA6ljatDyp3OkDGxz5Ae&#10;iqNk/4TZCQ0sgwppg6gfptpAe3l5eWh+fn68qqpbR0dHvzY8PPwf7Xb763VgMQ6MV1U1DgwVRdEP&#10;D1gl6YlYIkHEEumPmCeBxAekLOANkqE4V/99nfrPVgYUm0f9WRgi45tvJ83bj9dfb6fbxO09TBtB&#10;U6pZktHj75NG7OfJde1Tcihiz5cGmhdkaYN64oknit/85jcj27ZtmxgZGZkaGhraVhTFrrIs7+p0&#10;Ot8CHiuK4rZ2uz1RBxbNRu8myCg+9/V6qHq+Nq9lkon4hKT/D5AyppP1ry+SAGK+fi3avCj4+3So&#10;CTLU4AHgmyST92/1r1kOpfXWe407SwKK54G/kuvceXJN81BEA8+gQuojnU5ntNPpbCvLci9wS6vV&#10;2tput8dardYkaf7eR0qobiYTqCZIydTVlk01gUHzfVlV1d9/rSgKyHWkOalr9g6cJun+4ySYmCbZ&#10;h9PAqfr7GU/u9EXqrMUo+Xlumri/RbeJ+wa8l2n9LJJMxAFSrvkW6aM4TgINx8Vq0/BCLA2AqqrG&#10;q6raCdxWFMUddIOKSVIm0oytHSElJdtJzfrW+vcrMi/9HN0AYIGUH1H/flUHFE0gUBV1VEE3+Fgk&#10;QcUZukHFp8AlAwhdizprcQMZ0fwwyVg8QgKN3STw8J6m66UkAwWOk8l0TanTR6QEyh4wbTpegKUB&#10;UZZlART1g37zoudrRXfR2B1kJ8A+0hRbkozCofp1lAQZKz1/nsQUf/9nfT5T0au3/Ml+CK2KnqzF&#10;LhJMPEQauR8DbiFBx6ANM9DGUZJr4iLJQrxLypxeJKWdTe+E1zttSgYV0ibSsw9gmDycDdO9DqyQ&#10;8qUlMkPdzII2nJ4m7htIcHEfKYf6dv39jSQj1xtYS9eq2Yp9imQnjpAMxetk0MQlct00oNCm5QVX&#10;ktR36k3cI2Sfyz6ySPJxkr24lSycvAH3MenaNLuHZkkW92Uype4IKXU6jaNiJcCgQpLUx+pei2ZL&#10;/f0kqLiPlEfdQ7ffQroay8AJsjfnJTIq9iCZ9LQALJvVlcKgQpLU13p2vDQlUXeS4OLfSe/QXpK5&#10;MGuhL6NDxlvPkD6J14G/kQzFMdKI7VQn6XMMKiRJA6EuiWqCi1tIxuJh4Gv1110kq9HsdZF6NY3Y&#10;F0lm4nUyKvZdepZympmQ/jkvqpKkgdLTbzFJxibfTHou/ovsubgFS6L0WSukb+ITkpF4of56nCyw&#10;mwdWzE5I/5pBhSRpoFVVNUx6Lh4izdzfBf4Xjp9VXCaN12/QXWB3GDgJzGEwIX0p1pdK2jDq2ni8&#10;gWs1FUWxDJysquoUcKgsy0/LslwqiuL+Vqu1qyiKsfV+j7quOiSQuEimN50EXiF9EwfJAlAzE9IV&#10;MlMhaUOoA4oWLszTGqqqqnXo0KHtY2NjD+/YseP/jI6OPt5qte4EtrZarRHyM6jB04yGvUwmN30I&#10;vA28SvZMfAScISVQNmFLV8GgQtKGUVVV4c1ca+23v/1t69vf/vb4nj17dp47d+4rw8PD39myZct3&#10;t27den+r1dpKmr29Pw6Gpvl6gQQTR0lGYj/plzhFpjw5Hla6Rl40JUmb1qOPPjrxy1/+cu9NN930&#10;ULvd/tbIyMh/Tk5O3j8xMbF1aGiovd7vT9dkiUxxegN4n2QjPiVZijPU/RKYmZBWhUGFJEkw+vOf&#10;//yuJ5544vGbb7750YmJifvb7fZXxsfHbxofHx8dGrIFsU+UJFg4T3ZKPA08R8bCnqn7ayStAU9h&#10;JEmCzve///1z7Xb77T/84Q/7Dx8+fGxmZmZhYmJieWxsbH5oaGiuqqpF0u/T9P94MLcxVCSYWCTB&#10;xEESSPwB+BPJVpwvimJl3d6htAl4QZQk6bPaP/nJT8a++c1v3vDggw9OtFqtHcPDw3dOTU09vH37&#10;9kfGxsbuabfbe6qqmiCHc+060GheWhtNiVJJN5BogokZMsnpCJnk9DIpeToHLNkrIa09L36SJP3P&#10;2r/61a+2fOc737lx7969O4eHh3cuLi7etLS0dHu73f7KxMTEfWNjY7e22+2tZOmeVl9JeiRmyMjX&#10;U2QU7On6+9OkT6L5/hwwWxRFZ13erbQJGVRIknSFpqampn7961/vuf/++/ft27fvjsnJyVvKsrxp&#10;YWFh79LS0r52u33L2NjY9vHx8ZGhoSGSyNBVWgYuAB8Dh0h50wfACRJAnCc7J+bsmZDWj1c5SZKu&#10;0muvvVa0Wq3ij3/84/D09PT2bdu23XPnnXd+7Y477nhg7969e3fv3r1lbGxsBBiqqmq4LMtxYKrd&#10;bt/QarXGi6Jwq3eUZI/EMslILJKdEvMk63AceIfsljhMMhKz9d9f4m4bad05zkKSpKv06KOPVkA1&#10;MjKy9KMf/ejM+Pj4+bIs36iqarjT6QzNzMwMTU9PD09PT08uLCzsHB0dvWPbtm1f3bVr1wOTk5P7&#10;hoeHd5CSqWbpXtME3qLu1+j5vp97Nio+2wfRvJpAYh64RHZJNFuuT5JsxCf199Ok/Gmp/nMGEtIG&#10;0q8XJ0mS+snQD3/4w5Ef//jHE/fdd9/Wffv2TW3ZsmViaGhotCzL4bIsR1qt1mir1RpvtVpbgJ3A&#10;rcC++utNwBSfDUD6Qe9kpjlSxnSW9D+crl9n69dFElhcIlmIebKUbqH+8ys2XEsbl0GFJEnrr7V/&#10;//6he++9d2R8fHyCBBA3kuBiB7ANGCdlVC2gKMuyqKqqVZZlM962KIqiaLVaFEXRvJrMRxsYrf8Z&#10;k/XXYYCyLKuyLKmqqirLsvefUbXb7SaT0DQ8T9TvZ0/93qZI1UNJt1zpEgkQLtSvi6Tv4QIpZTpf&#10;f21+b5YEHIskC2HwIPUhgwpJkvpPb5lUqyiK1k9/+tPioYceKu6++2727dvH1q1bi8nJyWJoaKhF&#10;HvzHSRAwBdxAPalqaWmJxcXFanl5uVpZWSlarVZreHiYkZGRamxsbLlufl6u/503ALcAdwN3kgzK&#10;KAkoLvKPWYhpulmIWbpZhw4JRD77H2U5k9S37KmQJKn/VEDnBz/4QTk1NcXu3bu5/fbb2b59O+Pj&#10;4wwNDdFkLGoFyRAUn3v9g38yqar3Qb8gQcRWkknZTrIgcyRDMUMChyVghbr3ge5uiQp7IaSBZKZC&#10;kiR9aVVVNVmSofpV0G267gAdgwZJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJktbC&#10;/wcO9A7eMaXQEQAAAABJRU5ErkJggg==&#10;"

     

       45
       45
       -
              id="image1"

     

       46
       46
       -
              x="-233.6257"

     

       47
       47
       -
              y="10.383364"

     

       48
       48
       -
              style="display:none" />

     

       49
       49
       -
           <path

     

       50
       50
       -
              fill="currentColor"

     

       51
       51
       -
              style="stroke-width:0.111183"

     

       52
       52
       -
              d="m 16.348974,24.09935 -0.06485,-0.03766 -0.202005,-0.0106 -0.202008,-0.01048 -0.275736,-0.02601 -0.275734,-0.02602 v -0.02649 -0.02648 l -0.204577,-0.04019 -0.204578,-0.04019 -0.167616,-0.08035 -0.167617,-0.08035 -0.0014,-0.04137 -0.0014,-0.04137 -0.266473,-0.143735 -0.266475,-0.143735 -0.276098,-0.20335 -0.2761,-0.203347 -0.262064,-0.251949 -0.262064,-0.25195 -0.22095,-0.284628 -0.220948,-0.284629 -0.170253,-0.284631 -0.170252,-0.284628 -0.01341,-0.0144 -0.0134,-0.0144 -0.141982,0.161297 -0.14198,0.1613 -0.22313,0.21426 -0.223132,0.214264 -0.186025,0.146053 -0.186023,0.14605 -0.252501,0.163342 -0.252502,0.163342 -0.249014,0.115348 -0.249013,0.115336 0.0053,0.03241 0.0053,0.03241 -0.1716725,0.04599 -0.171669,0.046 -0.3379966,0.101058 -0.3379972,0.101058 -0.1778925,0.04506 -0.1778935,0.04508 -0.3913655,0.02601 -0.3913643,0.02603 -0.3557868,-0.03514 -0.3557863,-0.03514 -0.037426,-0.03029 -0.037427,-0.03029 -0.076924,0.02011 -0.076924,0.02011 -0.050508,-0.05051 -0.050405,-0.05056 L 6.6604532,23.110188 6.451745,23.063961 6.1546135,22.960559 5.8574835,22.857156 5.5319879,22.694039 5.2064938,22.530922 4.8793922,22.302961 4.5522905,22.075005 4.247598,21.786585 3.9429055,21.49817 3.7185335,21.208777 3.4941628,20.919385 3.3669822,20.705914 3.239803,20.492443 3.1335213,20.278969 3.0272397,20.065499 2.9015252,19.7275 2.7758105,19.389504 2.6925225,18.998139 2.6092345,18.606774 2.6096814,17.91299 2.6101284,17.219208 2.6744634,16.90029 2.7387984,16.581374 2.8474286,16.242088 2.9560588,15.9028 3.1137374,15.583492 3.2714148,15.264182 3.3415068,15.150766 3.4115988,15.03735 3.3127798,14.96945 3.2139618,14.90157 3.0360685,14.800239 2.8581753,14.698908 2.5913347,14.503228 2.3244955,14.307547 2.0621238,14.055599 1.7997507,13.803651 1.6111953,13.56878 1.4226411,13.333906 1.2632237,13.087474 1.1038089,12.841042 0.97442,12.575195 0.8450307,12.30935 0.724603,11.971351 0.6041766,11.633356 0.52150365,11.241991 0.4388285,10.850626 0.44091592,10.156842 0.44300333,9.4630594 0.54235911,9.0369608 0.6417149,8.6108622 0.7741173,8.2694368 0.9065196,7.9280115 1.0736303,7.6214262 1.2407515,7.3148397 1.45931,7.0191718 1.6778685,6.7235039 1.9300326,6.4611321 2.1821966,6.1987592 2.4134579,6.0137228 2.6447193,5.8286865 2.8759792,5.6776409 3.1072406,5.526594 3.4282004,5.3713977 3.7491603,5.2162016 3.9263009,5.1508695 4.1034416,5.0855373 4.2813348,4.7481598 4.4592292,4.4107823 4.6718,4.108422 4.8843733,3.8060618 5.198353,3.4805372 5.5123313,3.155014 5.7685095,2.9596425 6.0246877,2.7642722 6.329187,2.5851365 6.6336863,2.406002 6.9497657,2.2751596 7.2658453,2.1443184 7.4756394,2.0772947 7.6854348,2.01027 8.0825241,1.931086 8.4796139,1.851902 l 0.5870477,0.00291 0.5870469,0.00291 0.4447315,0.092455 0.444734,0.092455 0.302419,0.1105495 0.302417,0.1105495 0.329929,0.1646046 0.32993,0.1646033 0.239329,-0.2316919 0.239329,-0.2316919 0.160103,-0.1256767 0.160105,-0.1256767 0.160102,-0.1021909 0.160105,-0.1021899 0.142315,-0.082328 0.142314,-0.082328 0.231262,-0.1090091 0.231259,-0.1090091 0.26684,-0.098743 0.266839,-0.098743 0.320208,-0.073514 0.320209,-0.073527 0.355787,-0.041833 0.355785,-0.041834 0.426942,0.023827 0.426945,0.023828 0.355785,0.071179 0.355788,0.0711791 0.284627,0.09267 0.284629,0.09267 0.28514,0.1310267 0.28514,0.1310255 0.238179,0.1446969 0.238174,0.1446979 0.259413,0.1955332 0.259413,0.1955319 0.290757,0.296774 0.290758,0.2967753 0.151736,0.1941581 0.151734,0.1941594 0.135326,0.2149951 0.135327,0.2149952 0.154755,0.3202073 0.154758,0.3202085 0.09409,0.2677358 0.09409,0.267737 0.06948,0.3319087 0.06948,0.3319099 0.01111,0.00808 0.01111,0.00808 0.444734,0.2173653 0.444734,0.2173665 0.309499,0.2161102 0.309497,0.2161101 0.309694,0.2930023 0.309694,0.2930037 0.18752,0.2348726 0.187524,0.2348727 0.166516,0.2574092 0.166519,0.2574108 0.15273,0.3260252 0.152734,0.3260262 0.08972,0.2668403 0.08971,0.2668391 0.08295,0.3913655 0.08295,0.3913652 -6.21e-4,0.6582049 -6.21e-4,0.658204 -0.06362,0.315725 -0.06362,0.315725 -0.09046,0.289112 -0.09046,0.289112 -0.122759,0.281358 -0.12276,0.281356 -0.146626,0.252323 -0.146629,0.252322 -0.190443,0.258668 -0.190448,0.258671 -0.254911,0.268356 -0.254911,0.268355 -0.286872,0.223127 -0.286874,0.223127 -0.320203,0.187693 -0.320209,0.187693 -0.04347,0.03519 -0.04347,0.03521 0.0564,0.12989 0.0564,0.129892 0.08728,0.213472 0.08728,0.213471 0.189755,0.729363 0.189753,0.729362 0.0652,0.302417 0.0652,0.302419 -0.0018,0.675994 -0.0018,0.675995 -0.0801,0.373573 -0.08009,0.373577 -0.09,0.266839 -0.09,0.26684 -0.190389,0.391364 -0.19039,0.391366 -0.223169,0.320207 -0.223167,0.320209 -0.303585,0.315294 -0.303584,0.315291 -0.284631,0.220665 -0.284629,0.220663 -0.220128,0.132359 -0.220127,0.132358 -0.242395,0.106698 -0.242394,0.106699 -0.08895,0.04734 -0.08895,0.04733 -0.249052,0.07247 -0.24905,0.07247 -0.322042,0.0574 -0.322044,0.0574 -0.282794,-0.003 -0.282795,-0.003 -0.07115,-0.0031 -0.07115,-0.0031 -0.177894,-0.0033 -0.177893,-0.0033 -0.124528,0.02555 -0.124528,0.02555 z m -4.470079,-5.349839 0.214838,-0.01739 0.206601,-0.06782 0.206602,-0.06782 0.244389,-0.117874 0.244393,-0.11786 0.274473,-0.206822 0.27447,-0.20682 0.229308,-0.257201 0.229306,-0.2572 0.219161,-0.28463 0.219159,-0.284629 0.188541,-0.284628 0.188543,-0.28463 0.214594,-0.373574 0.214593,-0.373577 0.133861,-0.312006 0.133865,-0.312007 0.02861,-0.01769 0.02861,-0.01769 0.197275,0.26212 0.197278,0.262119 0.163613,0.150814 0.163614,0.150814 0.201914,0.09276 0.201914,0.09276 0.302417,0.01421 0.302418,0.01421 0.213472,-0.08025 0.213471,-0.08025 0.200606,-0.204641 0.200606,-0.204642 0.09242,-0.278887 0.09241,-0.278888 0.05765,-0.302418 0.05764,-0.302416 L 18.41327,13.768114 18.39502,13.34117 18.31849,12.915185 18.24196,12.4892 18.15595,12.168033 18.06994,11.846867 17.928869,11.444534 17.787801,11.042201 17.621278,10.73296 17.454757,10.423723 17.337388,10.263619 17.220021,10.103516 17.095645,9.9837986 16.971268,9.8640816 16.990048,9.6813736 17.008828,9.4986654 16.947568,9.249616 16.886308,9.0005655 16.752419,8.7159355 16.618521,8.4313217 16.435707,8.2294676 16.252892,8.0276114 16.079629,7.9004245 15.906366,7.773238 l -0.20429,0.1230127 -0.204289,0.1230121 -0.26702,0.059413 -0.267022,0.059413 -0.205761,-0.021508 -0.205766,-0.021508 -0.23495,-0.08844 -0.234953,-0.08844 -0.118429,-0.090334 -0.118428,-0.090333 h -0.03944 -0.03944 L 13.711268,7.8540732 13.655958,7.9706205 13.497227,8.1520709 13.338499,8.3335203 13.168394,8.4419112 12.998289,8.550301 12.777045,8.624223 12.5558,8.698155 H 12.275611 11.995429 L 11.799973,8.6309015 11.604513,8.5636472 11.491311,8.5051061 11.37811,8.446565 11.138172,8.2254579 10.898231,8.0043497 l -0.09565,-0.084618 -0.09565,-0.084613 -0.218822,0.198024 -0.218822,0.1980231 -0.165392,0.078387 -0.1653925,0.078387 -0.177894,0.047948 -0.177892,0.047948 L 9.3635263,8.4842631 9.144328,8.4846889 8.9195029,8.4147138 8.6946778,8.3447386 8.5931214,8.4414036 8.491565,8.5380686 8.3707618,8.7019598 8.2499597,8.8658478 8.0802403,8.9290726 7.9105231,8.9922974 7.7952769,9.0780061 7.6800299,9.1637148 7.5706169,9.2778257 7.4612038,9.3919481 7.1059768,9.9205267 6.7507497,10.449105 l -0.2159851,0.449834 -0.2159839,0.449834 -0.2216572,0.462522 -0.2216559,0.462523 -0.1459343,0.337996 -0.1459342,0.337998 -0.055483,0.220042 -0.055483,0.220041 -0.015885,0.206903 -0.015872,0.206901 0.034307,0.242939 0.034307,0.24294 0.096281,0.196632 0.096281,0.196634 0.143607,0.125222 0.1436071,0.125222 0.1873143,0.08737 0.1873141,0.08737 0.2752084,0.002 0.2752084,0.002 0.2312297,-0.09773 0.231231,-0.09772 0.1067615,-0.07603 0.1067614,-0.07603 0.3679062,-0.29377 0.3679065,-0.293771 0.026804,0.01656 0.026804,0.01656 0.023626,0.466819 0.023626,0.466815 0.088326,0.513195 0.088326,0.513193 0.08897,0.364413 0.08897,0.364411 0.1315362,0.302418 0.1315352,0.302418 0.1051964,0.160105 0.1051954,0.160103 0.1104741,0.11877 0.1104731,0.118769 0.2846284,0.205644 0.2846305,0.205642 0.144448,0.07312 0.144448,0.07312 0.214787,0.05566 0.214787,0.05566 0.245601,0.03075 0.245602,0.03075 0.204577,-0.0125 0.204578,-0.0125 z m 0.686342,-3.497495 -0.11281,-0.06077 -0.106155,-0.134033 -0.106155,-0.134031 -0.04406,-0.18371 -0.04406,-0.183707 0.02417,-0.553937 0.02417,-0.553936 0.03513,-0.426945 0.03513,-0.426942 0.07225,-0.373576 0.07225,-0.373575 0.05417,-0.211338 0.05417,-0.211339 0.0674,-0.132112 0.0674,-0.132112 0.132437,-0.10916 0.132437,-0.109161 0.187436,-0.04195 0.187438,-0.04195 0.170366,0.06469 0.170364,0.06469 0.114312,0.124073 0.114313,0.124086 0.04139,0.18495 0.04139,0.184951 -0.111218,0.459845 -0.111219,0.459844 -0.03383,0.26584 -0.03382,0.265841 -0.03986,0.818307 -0.03986,0.818309 -0.0378,0.15162 -0.03779,0.151621 -0.11089,0.110562 -0.110891,0.110561 -0.114489,0.04913 -0.114489,0.04913 -0.187932,-0.0016 -0.187929,-0.0016 z m -2.8087655,-0.358124 -0.146445,-0.06848 -0.088025,-0.119502 -0.088024,-0.119502 -0.038581,-0.106736 -0.038581,-0.106736 -0.02237,-0.134956 -0.02239,-0.134957 -0.031955,-0.46988 -0.031955,-0.469881 0.036203,-0.444733 0.036203,-0.444731 0.048862,-0.215257 0.048862,-0.215255 0.076082,-0.203349 0.076081,-0.203348 0.0936,-0.111244 0.0936,-0.111245 0.143787,-0.06531 0.1437865,-0.06532 h 0.142315 0.142314 l 0.142314,0.06588 0.142316,0.06588 0.093,0.102325 0.093,0.102325 0.04042,0.120942 0.04042,0.120942 v 0.152479 0.152477 l -0.03347,0.08804 -0.03347,0.08805 -0.05693,0.275653 -0.05693,0.275651 2.11e-4,0.430246 2.12e-4,0.430243 0.04294,0.392646 0.04295,0.392647 -0.09189,0.200702 -0.09189,0.200702 -0.148688,0.0984 -0.148687,0.0984 -0.20136,0.01212 -0.2013595,0.01212 z"

     

       53
       53
       -
              id="path4" />

     

       54
       54
       -
         </g>

     

       55
       55
       -
       </svg>

     

       2
       2
       +
         <svg

     

       3
       3
       +
            version="1.1"

     

       4
       4
       +
            id="svg1"

     

       5
       5
       +
            class="{{ . }}"

     

       6
       6
       +
            width="25"

     

       7
       7
       +
            height="25"

     

       8
       8
       +
            viewBox="0 0 25 25"

     

       9
       9
       +
            sodipodi:docname="tangled_dolly_face_only_black_on_trans.svg"

     

       10
       10
       +
            inkscape:export-filename="tangled_logotype_black_on_trans.svg"

     

       11
       11
       +
            inkscape:export-xdpi="96"

     

       12
       12
       +
            inkscape:export-ydpi="96"

     

       13
       13
       +
            inkscape:version="1.4 (e7c3feb100, 2024-10-09)"

     

       14
       14
       +
            xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       15
       15
       +
            xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       16
       16
       +
            xmlns="http://www.w3.org/2000/svg"

     

       17
       17
       +
            xmlns:svg="http://www.w3.org/2000/svg"

     

       18
       18
       +
            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

     

       19
       19
       +
            xmlns:cc="http://creativecommons.org/ns#">

     

       20
       20
       +
           <sodipodi:namedview

     

       21
       21
       +
              id="namedview1"

     

       22
       22
       +
              pagecolor="#ffffff"

     

       23
       23
       +
              bordercolor="#000000"

     

       24
       24
       +
              borderopacity="0.25"

     

       25
       25
       +
              inkscape:showpageshadow="2"

     

       26
       26
       +
              inkscape:pageopacity="0.0"

     

       27
       27
       +
              inkscape:pagecheckerboard="true"

     

       28
       28
       +
              inkscape:deskcolor="#d5d5d5"

     

       29
       29
       +
              inkscape:zoom="45.254834"

     

       30
       30
       +
              inkscape:cx="3.1377863"

     

       31
       31
       +
              inkscape:cy="8.9382717"

     

       32
       32
       +
              inkscape:window-width="3840"

     

       33
       33
       +
              inkscape:window-height="2160"

     

       34
       34
       +
              inkscape:window-x="0"

     

       35
       35
       +
              inkscape:window-y="0"

     

       36
       36
       +
              inkscape:window-maximized="0"

     

       37
       37
       +
              inkscape:current-layer="g1"

     

       38
       38
       +
              borderlayer="true">

     

       39
       39
       +
             <inkscape:page

     

       40
       40
       +
                x="0"

     

       41
       41
       +
                y="0"

     

       42
       42
       +
                width="25"

     

       43
       43
       +
                height="25"

     

       44
       44
       +
                id="page2"

     

       45
       45
       +
                margin="0"

     

       46
       46
       +
                bleed="0" />

     

       47
       47
       +
           </sodipodi:namedview>

     

       48
       48
       +
           <g

     

       49
       49
       +
              inkscape:groupmode="layer"

     

       50
       50
       +
              inkscape:label="Image"

     

       51
       51
       +
              id="g1"

     

       52
       52
       +
              transform="translate(-0.42924038,-0.87777209)">

     

       53
       53
       +
             <path

     

       54
       54
       +
                fill="currentColor"

     

       55
       55
       +
                style="stroke-width:0.111183;"

     

       56
       56
       +
                d="m 16.775491,24.987061 c -0.78517,-0.0064 -1.384202,-0.234614 -2.033994,-0.631295 -0.931792,-0.490188 -1.643475,-1.31368 -2.152014,-2.221647 C 11.781409,23.136647 10.701392,23.744942 9.4922931,24.0886 8.9774725,24.238111 8.0757679,24.389777 6.5811304,23.84827 4.4270703,23.124679 2.8580086,20.883331 3.0363279,18.599583 3.0037061,17.652919 3.3488675,16.723769 3.8381157,15.925061 2.5329485,15.224503 1.4686756,14.048584 1.0611184,12.606459 0.81344502,11.816973 0.82385989,10.966486 0.91519098,10.154906 1.2422711,8.2387903 2.6795811,6.5725716 4.5299585,5.9732484 5.2685364,4.290122 6.8802592,3.0349975 8.706276,2.7794663 c 1.2124148,-0.1688264 2.46744,0.084987 3.52811,0.7011837 1.545426,-1.7139736 4.237779,-2.2205077 6.293579,-1.1676231 1.568222,0.7488935 2.689625,2.3113526 2.961888,4.0151464 1.492195,0.5977882 2.749007,1.8168898 3.242225,3.3644951 0.329805,0.9581836 0.340709,2.0135956 0.127128,2.9974286 -0.381606,1.535184 -1.465322,2.842146 -2.868035,3.556463 0.0034,0.273204 0.901506,2.243045 0.751284,3.729647 -0.03281,1.858525 -1.211631,3.619894 -2.846433,4.475452 -0.953967,0.556812 -2.084452,0.546309 -3.120531,0.535398 z m -4.470079,-5.349839 c 1.322246,-0.147248 2.189053,-1.300106 2.862307,-2.338363 0.318287,-0.472954 0.561404,-1.002348 0.803,-1.505815 0.313265,0.287151 0.578698,0.828085 1.074141,0.956909 0.521892,0.162542 1.133743,0.03052 1.45325,-0.443554 0.611414,-1.140449 0.31004,-2.516537 -0.04602,-3.698347 C 18.232844,11.92927 17.945151,11.232927 17.397785,10.751793 17.514522,9.9283111 17.026575,9.0919791 16.332883,8.6609491 15.741721,9.1323278 14.842258,9.1294949 14.271975,8.6252369 13.178927,9.7400102 12.177239,9.7029996 11.209704,8.8195135 10.992255,8.6209543 10.577326,10.031484 9.1211947,9.2324497 8.2846288,9.9333947 7.6359672,10.607693 7.0611981,11.578553 6.5026891,12.62523 5.9177873,13.554793 5.867393,14.69141 c -0.024234,0.66432 0.4948601,1.360337 1.1982269,1.306329 0.702996,0.06277 1.1815208,-0.629091 1.7138087,-0.916491 0.079382,0.927141 0.1688108,1.923227 0.4821259,2.828358 0.3596254,1.171275 1.6262605,1.915695 2.8251855,1.745211 0.08481,-0.0066 0.218672,-0.01769 0.218672,-0.0176 z m 0.686342,-3.497495 c -0.643126,-0.394168 -0.33365,-1.249599 -0.359402,-1.870938 0.064,-0.749774 0.115321,-1.538054 0.452402,-2.221125 0.356724,-0.487008 1.226721,-0.299139 1.265134,0.325689 -0.02558,0.628509 -0.314101,1.25416 -0.279646,1.9057 -0.07482,0.544043 0.05418,1.155133 -0.186476,1.652391 -0.197455,0.275121 -0.599638,0.355105 -0.892012,0.208283 z m -2.808766,-0.358124 c -0.605767,-0.328664 -0.4133176,-1.155655 -0.5083256,-1.73063 0.078762,-0.66567 0.013203,-1.510085 0.5705316,-1.976886 0.545037,-0.380109 1.286917,0.270803 1.029164,0.868384 -0.274913,0.755214 -0.09475,1.580345 -0.08893,2.34609 -0.104009,0.451702 -0.587146,0.691508 -1.002445,0.493042 z"

     

       57
       57
       +
                id="path4"

     

       58
       58
       +
                sodipodi:nodetypes="sccccccccccccccccccsscccccccccsccccccccccccccccccccccc" />

     

       59
       59
       +
           </g>

     

       60
       60
       +
           <metadata

     

       61
       61
       +
              id="metadata1">

     

       62
       62
       +
             <rdf:RDF>

     

       63
       63
       +
               <cc:Work

     

       64
       64
       +
                  rdf:about="">

     

       65
       65
       +
                 <cc:license

     

       66
       66
       +
                    rdf:resource="http://creativecommons.org/licenses/by/4.0/" />

     

       67
       67
       +
               </cc:Work>

     

       68
       68
       +
               <cc:License

     

       69
       69
       +
                  rdf:about="http://creativecommons.org/licenses/by/4.0/">

     

       70
       70
       +
                 <cc:permits

     

       71
       71
       +
                    rdf:resource="http://creativecommons.org/ns#Reproduction" />

     

       72
       72
       +
                 <cc:permits

     

       73
       73
       +
                    rdf:resource="http://creativecommons.org/ns#Distribution" />

     

       74
       74
       +
                 <cc:requires

     

       75
       75
       +
                    rdf:resource="http://creativecommons.org/ns#Notice" />

     

       76
       76
       +
                 <cc:requires

     

       77
       77
       +
                    rdf:resource="http://creativecommons.org/ns#Attribution" />

     

       78
       78
       +
                 <cc:permits

     

       79
       79
       +
                    rdf:resource="http://creativecommons.org/ns#DerivativeWorks" />

     

       80
       80
       +
               </cc:License>

     

       81
       81
       +
             </rdf:RDF>

     

       82
       82
       +
           </metadata>

     

       83
       83
       +
         </svg>

     

       56
       84
        
       {{ end }}

+60 -22

appview/pages/templates/fragments/dolly/silhouette.html

···

       2
       2
        
       <svg

     

       3
       3
        
          version="1.1"

     

       4
       4
        
          id="svg1"

     

       5
       5
       -
          width="32"

     

       6
       6
       -
          height="32"

     

       5
       5
       +
          width="25"

     

       6
       6
       +
          height="25"

     

       7
       7
        
          viewBox="0 0 25 25"

     

       8
       8
       -
          sodipodi:docname="tangled_dolly_silhouette.png"

     

       8
       8
       +
          sodipodi:docname="tangled_dolly_face_only_black_on_trans.svg"

     

       9
       9
       +
          inkscape:export-filename="tangled_dolly_silhouette_black_on_trans.svg"

     

       10
       10
       +
          inkscape:export-xdpi="96"

     

       11
       11
       +
          inkscape:export-ydpi="96"

     

       12
       12
       +
          inkscape:version="1.4 (e7c3feb100, 2024-10-09)"

     

       9
       13
        
          xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       10
       14
        
          xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       11
       15
        
          xmlns="http://www.w3.org/2000/svg"

     

       12
       12
       -
          xmlns:svg="http://www.w3.org/2000/svg">

     

       13
       13
       -
         <style>

     

       14
       14
       -
           .dolly {

     

       15
       15
       -
             color: #000000;

     

       16
       16
       -
           }

     

       16
       16
       +
          xmlns:svg="http://www.w3.org/2000/svg"

     

       17
       17
       +
          xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

     

       18
       18
       +
          xmlns:cc="http://creativecommons.org/ns#">

     

       19
       19
       +
          <style>

     

       20
       20
       +
            .dolly {

     

       21
       21
       +
              color: #000000;

     

       22
       22
       +
            }

     

       17
       23
        
       

     

       18
       18
       -
           @media (prefers-color-scheme: dark) {

     

       19
       19
       -
             .dolly {

     

       20
       20
       -
               color: #ffffff;

     

       21
       21
       -
             }

     

       22
       22
       -
           }

     

       23
       23
       -
         </style>

     

       24
       24
       -
         <title>Dolly</title>

     

       25
       25
       -
         <defs

     

       26
       26
       -
            id="defs1" />

     

       24
       24
       +
            @media (prefers-color-scheme: dark) {

     

       25
       25
       +
              .dolly {

     

       26
       26
       +
                color: #ffffff;

     

       27
       27
       +
              }

     

       28
       28
       +
            }

     

       29
       29
       +
          </style>

     

       27
       30
        
         <sodipodi:namedview

     

       28
       31
        
            id="namedview1"

     

       29
       32
        
            pagecolor="#ffffff"

     
···

       32
       35
        
            inkscape:showpageshadow="2"

     

       33
       36
        
            inkscape:pageopacity="0.0"

     

       34
       37
        
            inkscape:pagecheckerboard="true"

     

       35
       35
       -
            inkscape:deskcolor="#d1d1d1">

     

       38
       38
       +
            inkscape:deskcolor="#d5d5d5"

     

       39
       39
       +
            inkscape:zoom="64"

     

       40
       40
       +
            inkscape:cx="4.96875"

     

       41
       41
       +
            inkscape:cy="13.429688"

     

       42
       42
       +
            inkscape:window-width="3840"

     

       43
       43
       +
            inkscape:window-height="2160"

     

       44
       44
       +
            inkscape:window-x="0"

     

       45
       45
       +
            inkscape:window-y="0"

     

       46
       46
       +
            inkscape:window-maximized="0"

     

       47
       47
       +
            inkscape:current-layer="g1"

     

       48
       48
       +
            borderlayer="true">

     

       36
       49
        
           <inkscape:page

     

       37
       50
        
              x="0"

     

       38
       51
        
              y="0"

     
···

       45
       58
        
         <g

     

       46
       59
        
            inkscape:groupmode="layer"

     

       47
       60
        
            inkscape:label="Image"

     

       48
       48
       -
            id="g1">

     

       61
       61
       +
            id="g1"

     

       62
       62
       +
            transform="translate(-0.42924038,-0.87777209)">

     

       49
       63
        
           <path

     

       50
       64
        
              class="dolly"

     

       51
       65
        
              fill="currentColor"

     

       52
       52
       -
              style="stroke-width:1.12248"

     

       53
       53
       -
              d="m 16.208435,23.914069 c -0.06147,-0.02273 -0.147027,-0.03034 -0.190158,-0.01691 -0.197279,0.06145 -1.31068,-0.230493 -1.388819,-0.364153 -0.01956,-0.03344 -0.163274,-0.134049 -0.319377,-0.223561 -0.550395,-0.315603 -1.010951,-0.696643 -1.428383,-1.181771 -0.264598,-0.307509 -0.597257,-0.785384 -0.597257,-0.857979 0,-0.0216 -0.02841,-0.06243 -0.06313,-0.0907 -0.04977,-0.04053 -0.160873,0.0436 -0.52488,0.397463 -0.479803,0.466432 -0.78924,0.689475 -1.355603,0.977118 -0.183693,0.0933 -0.323426,0.179989 -0.310516,0.192658 0.02801,0.02748 -0.7656391,0.270031 -1.209129,0.369517 -0.5378332,0.120647 -1.6341809,0.08626 -1.9721503,-0.06186 C 6.7977157,23.031391 6.56735,22.957551 6.3371134,22.889782 4.9717169,22.487902 3.7511914,21.481518 3.1172396,20.234838 2.6890391,19.392772 2.5582276,18.827446 2.5610489,17.831154 2.5639589,16.802192 2.7366641,16.125844 3.2142117,15.273187 3.3040457,15.112788 3.3713143,14.976533 3.3636956,14.9704 3.3560756,14.9643 3.2459634,14.90305 3.1189994,14.834381 1.7582586,14.098312 0.77760984,12.777439 0.44909837,11.23818 0.33531456,10.705039 0.33670119,9.7067968 0.45195381,9.1778795 0.72259241,7.9359287 1.3827188,6.8888436 2.4297498,6.0407205 2.6856126,5.8334648 3.2975489,5.4910878 3.6885849,5.3364049 L 4.0584319,5.190106 4.2333984,4.860432 C 4.8393906,3.7186139 5.8908314,2.7968028 7.1056396,2.3423025 7.7690673,2.0940921 8.2290216,2.0150935 9.01853,2.0137575 c 0.9625627,-0.00163 1.629181,0.1532762 2.485864,0.5776514 l 0.271744,0.1346134 0.42911,-0.3607688 c 1.082666,-0.9102346 2.185531,-1.3136811 3.578383,-1.3090327 0.916696,0.00306 1.573918,0.1517893 2.356121,0.5331927 1.465948,0.7148 2.54506,2.0625628 2.865177,3.57848 l 0.07653,0.362429 0.515095,0.2556611 c 1.022872,0.5076874 1.756122,1.1690944 2.288361,2.0641468 0.401896,0.6758594 0.537303,1.0442682 0.675505,1.8378683 0.288575,1.6570823 -0.266229,3.3548023 -1.490464,4.5608743 -0.371074,0.36557 -0.840205,0.718265 -1.203442,0.904754 -0.144112,0.07398 -0.271303,0.15826 -0.282647,0.187269 -0.01134,0.02901 0.02121,0.142764 0.07234,0.25279 0.184248,0.396467 0.451371,1.331823 0.619371,2.168779 0.463493,2.30908 -0.754646,4.693707 -2.92278,5.721632 -0.479538,0.227352 -0.717629,0.309322 -1.144194,0.39393 -0.321869,0.06383 -1.850573,0.09139 -2.000174,0.03604 z M 12.25443,18.636956 c 0.739923,-0.24652 1.382521,-0.718922 1.874623,-1.37812 0.0752,-0.100718 0.213883,-0.275851 0.308198,-0.389167 0.09432,-0.113318 0.210136,-0.271056 0.257381,-0.350531 0.416347,-0.700389 0.680936,-1.176102 0.766454,-1.378041 0.05594,-0.132087 0.114653,-0.239607 0.130477,-0.238929 0.01583,6.79e-4 0.08126,0.08531 0.145412,0.188069 0.178029,0.285173 0.614305,0.658998 0.868158,0.743878 0.259802,0.08686 0.656158,0.09598 0.911369,0.02095 0.213812,-0.06285 0.507296,-0.298016 0.645179,-0.516947 0.155165,-0.246374 0.327989,-0.989595 0.327989,-1.410501 0,-1.26718 -0.610975,-3.143405 -1.237774,-3.801045 -0.198483,-0.2082486 -0.208557,-0.2319396 -0.208557,-0.4904655 0,-0.2517771 -0.08774,-0.5704927 -0.258476,-0.938956 C 16.694963,8.50313 16.375697,8.1377479 16.135846,7.9543702 L 15.932296,7.7987471 15.683004,7.9356529 C 15.131767,8.2383821 14.435638,8.1945733 13.943459,7.8261812 L 13.782862,7.7059758 13.686773,7.8908012 C 13.338849,8.5600578 12.487087,8.8811064 11.743178,8.6233891 11.487199,8.5347109 11.358897,8.4505994 11.063189,8.1776138 L 10.69871,7.8411436 10.453484,8.0579255 C 10.318608,8.1771557 10.113778,8.3156283 9.9983037,8.3656417 9.7041488,8.4930449 9.1808299,8.5227884 8.8979004,8.4281886 8.7754792,8.3872574 8.6687415,8.3537661 8.6607053,8.3537661 c -0.03426,0 -0.3092864,0.3066098 -0.3791974,0.42275 -0.041935,0.069664 -0.1040482,0.1266636 -0.1380294,0.1266636 -0.1316419,0 -0.4197402,0.1843928 -0.6257041,0.4004735 -0.1923125,0.2017571 -0.6853701,0.9036038 -0.8926582,1.2706578 -0.042662,0.07554 -0.1803555,0.353687 -0.3059848,0.618091 -0.1256293,0.264406 -0.3270073,0.686768 -0.4475067,0.938581 -0.1204992,0.251816 -0.2469926,0.519654 -0.2810961,0.595199 -0.2592829,0.574347 -0.285919,1.391094 -0.057822,1.77304 0.1690683,0.283105 0.4224039,0.480895 0.7285507,0.568809 0.487122,0.139885 0.9109638,-0.004 1.6013422,-0.543768 l 0.4560939,-0.356568 0.0036,0.172041 c 0.01635,0.781837 0.1831084,1.813183 0.4016641,2.484154 0.1160449,0.356262 0.3781448,0.83968 0.5614081,1.035462 0.2171883,0.232025 0.7140951,0.577268 1.0100284,0.701749 0.121485,0.0511 0.351032,0.110795 0.510105,0.132647 0.396966,0.05452 1.2105,0.02265 1.448934,-0.05679 z"

     

       54
       54
       -
              id="path1" />

     

       66
       66
       +
              style="stroke-width:0.111183"

     

       67
       67
       +
              d="m 16.775491,24.987061 c -0.78517,-0.0064 -1.384202,-0.234614 -2.033994,-0.631295 -0.931792,-0.490188 -1.643475,-1.31368 -2.152014,-2.221647 C 11.781409,23.136647 10.701392,23.744942 9.4922931,24.0886 8.9774725,24.238111 8.0757679,24.389777 6.5811304,23.84827 4.4270703,23.124679 2.8580086,20.883331 3.0363279,18.599583 3.0037061,17.652919 3.3488675,16.723769 3.8381157,15.925061 2.5329485,15.224503 1.4686756,14.048584 1.0611184,12.606459 0.81344502,11.816973 0.82385989,10.966486 0.91519098,10.154906 1.2422711,8.2387903 2.6795811,6.5725716 4.5299585,5.9732484 5.2685364,4.290122 6.8802592,3.0349975 8.706276,2.7794663 c 1.2124148,-0.1688264 2.46744,0.084987 3.52811,0.7011837 1.545426,-1.7139736 4.237779,-2.2205077 6.293579,-1.1676231 1.568222,0.7488935 2.689625,2.3113526 2.961888,4.0151464 1.492195,0.5977882 2.749007,1.8168898 3.242225,3.3644951 0.329805,0.9581836 0.340709,2.0135956 0.127128,2.9974286 -0.381606,1.535184 -1.465322,2.842146 -2.868035,3.556463 0.0034,0.273204 0.901506,2.243045 0.751284,3.729647 -0.03281,1.858525 -1.211631,3.619894 -2.846433,4.475452 -0.953967,0.556812 -2.084452,0.546309 -3.120531,0.535398 z m -4.470079,-5.349839 c 1.322246,-0.147248 2.189053,-1.300106 2.862307,-2.338363 0.318287,-0.472954 0.561404,-1.002348 0.803,-1.505815 0.313265,0.287151 0.578698,0.828085 1.074141,0.956909 0.521892,0.162542 1.133743,0.03052 1.45325,-0.443554 0.611414,-1.140449 0.31004,-2.516537 -0.04602,-3.698347 C 18.232844,11.92927 17.945151,11.232927 17.397785,10.751793 17.514522,9.9283111 17.026575,9.0919791 16.332883,8.6609491 15.741721,9.1323278 14.842258,9.1294949 14.271975,8.6252369 13.178927,9.7400102 12.177239,9.7029996 11.209704,8.8195135 10.992255,8.6209543 10.577326,10.031484 9.1211947,9.2324497 8.2846288,9.9333947 7.6359672,10.607693 7.0611981,11.578553 6.5026891,12.62523 5.9177873,13.554793 5.867393,14.69141 c -0.024234,0.66432 0.4948601,1.360337 1.1982269,1.306329 0.702996,0.06277 1.1815208,-0.629091 1.7138087,-0.916491 0.079382,0.927141 0.1688108,1.923227 0.4821259,2.828358 0.3596254,1.171275 1.6262605,1.915695 2.8251855,1.745211 0.08481,-0.0066 0.218672,-0.01769 0.218672,-0.0176 z"

     

       68
       68
       +
              id="path7"

     

       69
       69
       +
              sodipodi:nodetypes="sccccccccccccccccccsscccccccccscccccccsc" />

     

       55
       70
        
         </g>

     

       71
       71
       +
         <metadata

     

       72
       72
       +
            id="metadata1">

     

       73
       73
       +
           <rdf:RDF>

     

       74
       74
       +
             <cc:Work

     

       75
       75
       +
                rdf:about="">

     

       76
       76
       +
               <cc:license

     

       77
       77
       +
                  rdf:resource="http://creativecommons.org/licenses/by/4.0/" />

     

       78
       78
       +
             </cc:Work>

     

       79
       79
       +
             <cc:License

     

       80
       80
       +
                rdf:about="http://creativecommons.org/licenses/by/4.0/">

     

       81
       81
       +
               <cc:permits

     

       82
       82
       +
                  rdf:resource="http://creativecommons.org/ns#Reproduction" />

     

       83
       83
       +
               <cc:permits

     

       84
       84
       +
                  rdf:resource="http://creativecommons.org/ns#Distribution" />

     

       85
       85
       +
               <cc:requires

     

       86
       86
       +
                  rdf:resource="http://creativecommons.org/ns#Notice" />

     

       87
       87
       +
               <cc:requires

     

       88
       88
       +
                  rdf:resource="http://creativecommons.org/ns#Attribution" />

     

       89
       89
       +
               <cc:permits

     

       90
       90
       +
                  rdf:resource="http://creativecommons.org/ns#DerivativeWorks" />

     

       91
       91
       +
             </cc:License>

     

       92
       92
       +
           </rdf:RDF>

     

       93
       93
       +
         </metadata>

     

       56
       94
        
       </svg>

     

       57
       95
        
       {{ end }}

-44

appview/pages/templates/fragments/dolly/silhouette.svg

···

       1
       1
       -
       <svg

     

       2
       2
       -
          version="1.1"

     

       3
       3
       -
          id="svg1"

     

       4
       4
       -
          width="32"

     

       5
       5
       -
          height="32"

     

       6
       6
       -
          viewBox="0 0 25 25"

     

       7
       7
       -
          sodipodi:docname="tangled_dolly_silhouette.png"

     

       8
       8
       -
          xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       9
       9
       -
          xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       10
       10
       -
          xmlns="http://www.w3.org/2000/svg"

     

       11
       11
       -
          xmlns:svg="http://www.w3.org/2000/svg">

     

       12
       12
       -
       <title>Dolly</title>

     

       13
       13
       -
         <defs

     

       14
       14
       -
            id="defs1" />

     

       15
       15
       -
         <sodipodi:namedview

     

       16
       16
       -
            id="namedview1"

     

       17
       17
       -
            pagecolor="#ffffff"

     

       18
       18
       -
            bordercolor="#000000"

     

       19
       19
       -
            borderopacity="0.25"

     

       20
       20
       -
            inkscape:showpageshadow="2"

     

       21
       21
       -
            inkscape:pageopacity="0.0"

     

       22
       22
       -
            inkscape:pagecheckerboard="true"

     

       23
       23
       -
            inkscape:deskcolor="#d1d1d1">

     

       24
       24
       -
           <inkscape:page

     

       25
       25
       -
              x="0"

     

       26
       26
       -
              y="0"

     

       27
       27
       -
              width="25"

     

       28
       28
       -
              height="25"

     

       29
       29
       -
              id="page2"

     

       30
       30
       -
              margin="0"

     

       31
       31
       -
              bleed="0" />

     

       32
       32
       -
         </sodipodi:namedview>

     

       33
       33
       -
         <g

     

       34
       34
       -
            inkscape:groupmode="layer"

     

       35
       35
       -
            inkscape:label="Image"

     

       36
       36
       -
            id="g1">

     

       37
       37
       -
           <path

     

       38
       38
       -
              class="dolly"

     

       39
       39
       -
              fill="currentColor"

     

       40
       40
       -
              style="stroke-width:1.12248"

     

       41
       41
       -
              d="m 16.208435,23.914069 c -0.06147,-0.02273 -0.147027,-0.03034 -0.190158,-0.01691 -0.197279,0.06145 -1.31068,-0.230493 -1.388819,-0.364153 -0.01956,-0.03344 -0.163274,-0.134049 -0.319377,-0.223561 -0.550395,-0.315603 -1.010951,-0.696643 -1.428383,-1.181771 -0.264598,-0.307509 -0.597257,-0.785384 -0.597257,-0.857979 0,-0.0216 -0.02841,-0.06243 -0.06313,-0.0907 -0.04977,-0.04053 -0.160873,0.0436 -0.52488,0.397463 -0.479803,0.466432 -0.78924,0.689475 -1.355603,0.977118 -0.183693,0.0933 -0.323426,0.179989 -0.310516,0.192658 0.02801,0.02748 -0.7656391,0.270031 -1.209129,0.369517 -0.5378332,0.120647 -1.6341809,0.08626 -1.9721503,-0.06186 C 6.7977157,23.031391 6.56735,22.957551 6.3371134,22.889782 4.9717169,22.487902 3.7511914,21.481518 3.1172396,20.234838 2.6890391,19.392772 2.5582276,18.827446 2.5610489,17.831154 2.5639589,16.802192 2.7366641,16.125844 3.2142117,15.273187 3.3040457,15.112788 3.3713143,14.976533 3.3636956,14.9704 3.3560756,14.9643 3.2459634,14.90305 3.1189994,14.834381 1.7582586,14.098312 0.77760984,12.777439 0.44909837,11.23818 0.33531456,10.705039 0.33670119,9.7067968 0.45195381,9.1778795 0.72259241,7.9359287 1.3827188,6.8888436 2.4297498,6.0407205 2.6856126,5.8334648 3.2975489,5.4910878 3.6885849,5.3364049 L 4.0584319,5.190106 4.2333984,4.860432 C 4.8393906,3.7186139 5.8908314,2.7968028 7.1056396,2.3423025 7.7690673,2.0940921 8.2290216,2.0150935 9.01853,2.0137575 c 0.9625627,-0.00163 1.629181,0.1532762 2.485864,0.5776514 l 0.271744,0.1346134 0.42911,-0.3607688 c 1.082666,-0.9102346 2.185531,-1.3136811 3.578383,-1.3090327 0.916696,0.00306 1.573918,0.1517893 2.356121,0.5331927 1.465948,0.7148 2.54506,2.0625628 2.865177,3.57848 l 0.07653,0.362429 0.515095,0.2556611 c 1.022872,0.5076874 1.756122,1.1690944 2.288361,2.0641468 0.401896,0.6758594 0.537303,1.0442682 0.675505,1.8378683 0.288575,1.6570823 -0.266229,3.3548023 -1.490464,4.5608743 -0.371074,0.36557 -0.840205,0.718265 -1.203442,0.904754 -0.144112,0.07398 -0.271303,0.15826 -0.282647,0.187269 -0.01134,0.02901 0.02121,0.142764 0.07234,0.25279 0.184248,0.396467 0.451371,1.331823 0.619371,2.168779 0.463493,2.30908 -0.754646,4.693707 -2.92278,5.721632 -0.479538,0.227352 -0.717629,0.309322 -1.144194,0.39393 -0.321869,0.06383 -1.850573,0.09139 -2.000174,0.03604 z M 12.25443,18.636956 c 0.739923,-0.24652 1.382521,-0.718922 1.874623,-1.37812 0.0752,-0.100718 0.213883,-0.275851 0.308198,-0.389167 0.09432,-0.113318 0.210136,-0.271056 0.257381,-0.350531 0.416347,-0.700389 0.680936,-1.176102 0.766454,-1.378041 0.05594,-0.132087 0.114653,-0.239607 0.130477,-0.238929 0.01583,6.79e-4 0.08126,0.08531 0.145412,0.188069 0.178029,0.285173 0.614305,0.658998 0.868158,0.743878 0.259802,0.08686 0.656158,0.09598 0.911369,0.02095 0.213812,-0.06285 0.507296,-0.298016 0.645179,-0.516947 0.155165,-0.246374 0.327989,-0.989595 0.327989,-1.410501 0,-1.26718 -0.610975,-3.143405 -1.237774,-3.801045 -0.198483,-0.2082486 -0.208557,-0.2319396 -0.208557,-0.4904655 0,-0.2517771 -0.08774,-0.5704927 -0.258476,-0.938956 C 16.694963,8.50313 16.375697,8.1377479 16.135846,7.9543702 L 15.932296,7.7987471 15.683004,7.9356529 C 15.131767,8.2383821 14.435638,8.1945733 13.943459,7.8261812 L 13.782862,7.7059758 13.686773,7.8908012 C 13.338849,8.5600578 12.487087,8.8811064 11.743178,8.6233891 11.487199,8.5347109 11.358897,8.4505994 11.063189,8.1776138 L 10.69871,7.8411436 10.453484,8.0579255 C 10.318608,8.1771557 10.113778,8.3156283 9.9983037,8.3656417 9.7041488,8.4930449 9.1808299,8.5227884 8.8979004,8.4281886 8.7754792,8.3872574 8.6687415,8.3537661 8.6607053,8.3537661 c -0.03426,0 -0.3092864,0.3066098 -0.3791974,0.42275 -0.041935,0.069664 -0.1040482,0.1266636 -0.1380294,0.1266636 -0.1316419,0 -0.4197402,0.1843928 -0.6257041,0.4004735 -0.1923125,0.2017571 -0.6853701,0.9036038 -0.8926582,1.2706578 -0.042662,0.07554 -0.1803555,0.353687 -0.3059848,0.618091 -0.1256293,0.264406 -0.3270073,0.686768 -0.4475067,0.938581 -0.1204992,0.251816 -0.2469926,0.519654 -0.2810961,0.595199 -0.2592829,0.574347 -0.285919,1.391094 -0.057822,1.77304 0.1690683,0.283105 0.4224039,0.480895 0.7285507,0.568809 0.487122,0.139885 0.9109638,-0.004 1.6013422,-0.543768 l 0.4560939,-0.356568 0.0036,0.172041 c 0.01635,0.781837 0.1831084,1.813183 0.4016641,2.484154 0.1160449,0.356262 0.3781448,0.83968 0.5614081,1.035462 0.2171883,0.232025 0.7140951,0.577268 1.0100284,0.701749 0.121485,0.0511 0.351032,0.110795 0.510105,0.132647 0.396966,0.05452 1.2105,0.02265 1.448934,-0.05679 z"

     

       42
       42
       -
              id="path1" />

     

       43
       43
       -
         </g>

     

       44
       44
       -
       </svg>

+28

appview/pages/templates/fragments/starBtn.html

···

       1
       1
       +
       {{ define "fragments/starBtn" }}

     

       2
       2
       +
           <button

     

       3
       3
       +
               id="starBtn"

     

       4
       4
       +
               class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       5
       +
               data-star-subject-at="{{ .SubjectAt }}"

     

       6
       6
       +
               {{ if .IsStarred }}

     

       7
       7
       +
                   hx-delete="/star?subject={{ .SubjectAt }}&countHint={{ .StarCount }}"

     

       8
       8
       +
               {{ else }}

     

       9
       9
       +
                   hx-post="/star?subject={{ .SubjectAt }}&countHint={{ .StarCount }}"

     

       10
       10
       +
               {{ end }}

     

       11
       11
       +
       

     

       12
       12
       +
               hx-trigger="click"

     

       13
       13
       +
               hx-target="this"

     

       14
       14
       +
               hx-swap="outerHTML"

     

       15
       15
       +
               hx-swap-oob='outerHTML:#starBtn[data-star-subject-at="{{ .SubjectAt }}"]'

     

       16
       16
       +
               hx-disabled-elt="#starBtn"

     

       17
       17
       +
           >

     

       18
       18
       +
               {{ if .IsStarred }}

     

       19
       19
       +
                   {{ i "star" "w-4 h-4 fill-current" }}

     

       20
       20
       +
               {{ else }}

     

       21
       21
       +
                   {{ i "star" "w-4 h-4" }}

     

       22
       22
       +
               {{ end }}

     

       23
       23
       +
               <span class="text-sm">

     

       24
       24
       +
                   {{ .StarCount }}

     

       25
       25
       +
               </span>

     

       26
       26
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       27
       27
       +
           </button>

     

       28
       28
       +
       {{ end }}

+33

appview/pages/templates/fragments/tabSelector.html

···

       1
       1
       +
       {{ define "fragments/tabSelector" }}

     

       2
       2
       +
         {{ $name := .Name }}

     

       3
       3
       +
         {{ $all := .Values }}

     

       4
       4
       +
         {{ $active := .Active }}

     

       5
       5
       +
         {{ $include := .Include }}

     

       6
       6
       +
         <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden">

     

       7
       7
       +
           {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }}

     

       8
       8
       +
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }}

     

       9
       9
       +
           {{ range $index, $value := $all }}

     

       10
       10
       +
             {{ $isActive := eq $value.Key $active }}

     

       11
       11
       +
             <a href="?{{ $name }}={{ $value.Key }}"

     

       12
       12
       +
                {{ if $include }}

     

       13
       13
       +
                hx-get="?{{ $name }}={{ $value.Key }}"

     

       14
       14
       +
                hx-include="{{ $include }}"

     

       15
       15
       +
                hx-push-url="true"

     

       16
       16
       +
                hx-target="body"

     

       17
       17
       +
                hx-on:htmx:config-request="if(!event.detail.parameters.q) delete event.detail.parameters.q"

     

       18
       18
       +
                {{ end }}

     

       19
       19
       +
                class="p-2 whitespace-nowrap flex justify-center items-center gap-2 text-sm w-full block hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       20
       20
       +
              {{ if $value.Icon }}

     

       21
       21
       +
                {{ i $value.Icon "size-4" }}

     

       22
       22
       +
              {{ end }}

     

       23
       23
       +
       

     

       24
       24
       +
              {{ with $value.Meta }}

     

       25
       25
       +
                {{ . }}

     

       26
       26
       +
              {{ end }}

     

       27
       27
       +
       

     

       28
       28
       +
              {{ $value.Value }}

     

       29
       29
       +
             </a>

     

       30
       30
       +
           {{ end }}

     

       31
       31
       +
         </div>

     

       32
       32
       +
       {{ end }}

     

       33
       33
       +

+22

appview/pages/templates/fragments/tinyAvatarList.html

···

       1
       1
       +
       {{ define "fragments/tinyAvatarList" }}

     

       2
       2
       +
         {{ $all := .all }}

     

       3
       3
       +
         {{ $classes := .classes }}

     

       4
       4
       +
         {{ $ps := take $all 5 }}

     

       5
       5
       +
         <div class="inline-flex items-center -space-x-3">

     

       6
       6
       +
           {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       7
       7
       +
           {{ range $i, $p := $ps }}

     

       8
       8
       +
             <img

     

       9
       9
       +
                 src="{{ tinyAvatar . }}"

     

       10
       10
       +
                 alt=""

     

       11
       11
       +
                 class="rounded-full size-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0 {{ $classes }}"

     

       12
       12
       +
             />

     

       13
       13
       +
           {{ end }}

     

       14
       14
       +
       

     

       15
       15
       +
           {{ if gt (len $all) 5 }}

     

       16
       16
       +
             <span class="pl-4 text-gray-500 dark:text-gray-400 text-sm">

     

       17
       17
       +
               +{{ sub (len $all) 5 }}

     

       18
       18
       +
             </span>

     

       19
       19
       +
           {{ end }}

     

       20
       20
       +
         </div>

     

       21
       21
       +
       {{ end }}

     

       22
       22
       +

+36

appview/pages/templates/fragments/workflow-timers.html

···

       1
       1
       +
       {{ define "fragments/workflow-timers" }}

     

       2
       2
       +
         <script>

     

       3
       3
       +
           function formatElapsed(seconds) {

     

       4
       4
       +
             if (seconds < 1) return '0s';

     

       5
       5
       +
             if (seconds < 60) return `${seconds}s`;

     

       6
       6
       +
             const minutes = Math.floor(seconds / 60);

     

       7
       7
       +
             const secs = seconds % 60;

     

       8
       8
       +
             if (seconds < 3600) return `${minutes}m ${secs}s`;

     

       9
       9
       +
             const hours = Math.floor(seconds / 3600);

     

       10
       10
       +
             const mins = Math.floor((seconds % 3600) / 60);

     

       11
       11
       +
             return `${hours}h ${mins}m`;

     

       12
       12
       +
           }

     

       13
       13
       +
       

     

       14
       14
       +
           function updateTimers() {

     

       15
       15
       +
             const now = Math.floor(Date.now() / 1000);

     

       16
       16
       +
       

     

       17
       17
       +
             document.querySelectorAll('[data-timer]').forEach(el => {

     

       18
       18
       +
               const startTime = parseInt(el.dataset.start);

     

       19
       19
       +
               const endTime = el.dataset.end ? parseInt(el.dataset.end) : null;

     

       20
       20
       +
       

     

       21
       21
       +
               if (endTime) {

     

       22
       22
       +
                 // Step is complete, show final time

     

       23
       23
       +
                 const elapsed = endTime - startTime;

     

       24
       24
       +
                 el.textContent = formatElapsed(elapsed);

     

       25
       25
       +
               } else {

     

       26
       26
       +
                 // Step is running, update live

     

       27
       27
       +
                 const elapsed = now - startTime;

     

       28
       28
       +
                 el.textContent = formatElapsed(elapsed);

     

       29
       29
       +
               }

     

       30
       30
       +
             });

     

       31
       31
       +
           }

     

       32
       32
       +
       

     

       33
       33
       +
           setInterval(updateTimers, 1000);

     

       34
       34
       +
           updateTimers();

     

       35
       35
       +
         </script>

     

       36
       36
       +
       {{ end }}

+23 -7

appview/pages/templates/knots/dashboard.html

···

       1
       1
       -
       {{ define "title" }}{{ .Registration.Domain }} &middot; knots{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Registration.Domain }} &middot; {{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4">

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "knotDash" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "knotDash" }}

     

       20
       20
       +
       <div>

     

       5
       21
        
         <div class="flex justify-between items-center">

     

       6
       6
       -
           <h1 class="text-xl font-bold dark:text-white">{{ .Registration.Domain }}</h1>

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">{{ .Tab }} &middot; {{ .Registration.Domain }}</h2>

     

       7
       23
        
           <div id="right-side" class="flex gap-2">

     

       8
       24
        
             {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       9
       25
        
             {{ $isOwner := and .LoggedInUser (eq .LoggedInUser.Did .Registration.ByDid)  }}

     
···

       35
       51
        
       </div>

     

       36
       52
        
       

     

       37
       53
        
       {{ if .Members }}

     

       38
       38
       -
         <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       54
       54
       +
         <section class="bg-white dark:bg-gray-800 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       39
       55
        
           <div class="flex flex-col gap-2">

     

       40
       56
        
             {{ block "member" . }} {{ end }}

     

       41
       57
        
           </div>

     
···

       79
       95
        
         <button

     

       80
       96
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       81
       97
        
           title="Delete knot"

     

       82
       82
       -
           hx-delete="/knots/{{ .Domain }}"

     

       98
       98
       +
           hx-delete="/settings/knots/{{ .Domain }}"

     

       83
       99
        
           hx-swap="outerHTML"

     

       84
       100
        
           hx-confirm="Are you sure you want to delete the knot '{{ .Domain }}'?"

     

       85
       101
        
           hx-headers='{"shouldRedirect": "true"}'

     
···

       95
       111
        
         <button

     

       96
       112
        
           class="btn gap-2 group"

     

       97
       113
        
           title="Retry knot verification"

     

       98
       98
       -
           hx-post="/knots/{{ .Domain }}/retry"

     

       114
       114
       +
           hx-post="/settings/knots/{{ .Domain }}/retry"

     

       99
       115
        
           hx-swap="none"

     

       100
       116
        
           hx-headers='{"shouldRefresh": "true"}'

     

       101
       117
        
         >

     
···

       113
       129
        
           <button

     

       114
       130
        
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       115
       131
        
             title="Remove member"

     

       116
       116
       -
             hx-post="/knots/{{ $root.Registration.Domain }}/remove"

     

       132
       132
       +
             hx-post="/settings/knots/{{ $root.Registration.Domain }}/remove"

     

       117
       133
        
             hx-swap="none"

     

       118
       134
        
             hx-vals='{"member": "{{$member}}" }'

     

       119
       135
        
             hx-confirm="Are you sure you want to remove {{ $memberHandle }} from this knot?"

+18 -10

appview/pages/templates/knots/fragments/addMemberModal.html

···

       13
       13
        
         <div

     

       14
       14
        
           id="add-member-{{ .Id }}"

     

       15
       15
        
           popover

     

       16
       16
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       16
       16
       +
           class="

     

       17
       17
       +
           bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50

     

       18
       18
       +
           w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       17
       19
        
           {{ block "addKnotMemberPopover" . }} {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     

       20
       22
        
       

     

       21
       23
        
       {{ define "addKnotMemberPopover" }}

     

       22
       24
        
       <form

     

       23
       23
       -
         hx-post="/knots/{{ .Domain }}/add"

     

       25
       25
       +
         hx-post="/settings/knots/{{ .Domain }}/add"

     

       24
       26
        
         hx-indicator="#spinner"

     

       25
       27
        
         hx-swap="none"

     

       26
       28
        
         class="flex flex-col gap-2"

     
···

       29
       31
        
           ADD MEMBER

     

       30
       32
        
         </label>

     

       31
       33
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can create repositories and run workflows on this knot.</p>

     

       32
       32
       -
         <input

     

       33
       33
       -
           type="text"

     

       34
       34
       -
           id="member-did-{{ .Id }}"

     

       35
       35
       -
           name="member"

     

       36
       36
       -
           required

     

       37
       37
       -
           placeholder="@foo.bsky.social"

     

       38
       38
       -
         />

     

       34
       34
       +
         <actor-typeahead>

     

       35
       35
       +
           <input

     

       36
       36
       +
             autocapitalize="none"

     

       37
       37
       +
             autocorrect="off"

     

       38
       38
       +
             autocomplete="off"

     

       39
       39
       +
             type="text"

     

       40
       40
       +
             id="member-did-{{ .Id }}"

     

       41
       41
       +
             name="member"

     

       42
       42
       +
             required

     

       43
       43
       +
             placeholder="user.tngl.sh"

     

       44
       44
       +
             class="w-full"

     

       45
       45
       +
           />

     

       46
       46
       +
         </actor-typeahead>

     

       39
       47
        
         <div class="flex gap-2 pt-2">

     

       40
       48
        
           <button 

     

       41
       49
        
             type="button"

     
···

       54
       62
        
         </div>

     

       55
       63
        
         <div id="add-member-error-{{ .Id }}" class="text-red-500 dark:text-red-400"></div>

     

       56
       64
        
       </form>

     

       57
       57
       -
       {{ end }}
     

       65
       65
       +
       {{ end }}

+3 -3

appview/pages/templates/knots/fragments/knotListing.html

···

       7
       7
        
       

     

       8
       8
        
       {{ define "knotLeftSide" }}

     

       9
       9
        
         {{ if .Registered }}

     

       10
       10
       -
         <a href="/knots/{{ .Domain }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       10
       10
       +
         <a href="/settings/knots/{{ .Domain }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       11
       11
        
           {{ i "hard-drive" "w-4 h-4" }}

     

       12
       12
        
           <span class="hover:underline">

     

       13
       13
        
             {{ .Domain }}

     
···

       56
       56
        
         <button

     

       57
       57
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       58
       58
        
           title="Delete knot"

     

       59
       59
       -
           hx-delete="/knots/{{ .Domain }}"

     

       59
       59
       +
           hx-delete="/settings/knots/{{ .Domain }}"

     

       60
       60
        
           hx-swap="outerHTML"

     

       61
       61
        
           hx-target="#knot-{{.Id}}"

     

       62
       62
        
           hx-confirm="Are you sure you want to delete the knot '{{ .Domain }}'?"

     
···

       72
       72
        
         <button

     

       73
       73
        
           class="btn gap-2 group"

     

       74
       74
        
           title="Retry knot verification"

     

       75
       75
       -
           hx-post="/knots/{{ .Domain }}/retry"

     

       75
       75
       +
           hx-post="/settings/knots/{{ .Domain }}/retry"

     

       76
       76
        
           hx-swap="none"

     

       77
       77
        
           hx-target="#knot-{{.Id}}"

     

       78
       78
        
         >

+42 -11

appview/pages/templates/knots/index.html

···

       1
       1
       -
       {{ define "title" }}knots{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom">

     

       5
       5
       -
         <h1 class="text-xl font-bold dark:text-white">Knots</h1>

     

       6
       6
       -
         <span class="flex items-center gap-1">

     

       7
       7
       -
             {{ i "book" "w-3 h-3" }}

     

       8
       8
       -
             <a href="https://tangled.org/@tangled.org/core/blob/master/docs/knot-hosting.md">docs</a>

     

       9
       9
       -
         </span>

     

       10
       10
       -
       </div>

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "knotsList" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "knotsList" }}

     

       20
       20
       +
         <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       21
       21
       +
           <div class="col-span-1 md:col-span-2">

     

       22
       22
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Knots</h2>

     

       23
       23
       +
             {{ block "about" . }} {{ end }}

     

       24
       24
       +
           </div>

     

       25
       25
       +
           <div class="col-span-1 md:col-span-1 md:justify-self-end">

     

       26
       26
       +
             {{ template "docsButton" . }}

     

       27
       27
       +
           </div>

     

       28
       28
       +
         </div>

     

       11
       29
        
       

     

       12
       12
       -
       <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       30
       30
       +
       <section>

     

       13
       31
        
         <div class="flex flex-col gap-6">

     

       14
       14
       -
           {{ block "about" . }} {{ end }}

     

       15
       32
        
           {{ block "list" . }} {{ end }}

     

       16
       33
        
           {{ block "register" . }} {{ end }}

     

       17
       34
        
         </div>

     
···

       50
       67
        
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a knot</h2>

     

       51
       68
        
           <p class="mb-2 dark:text-gray-300">Enter the hostname of your knot to get started.</p>

     

       52
       69
        
           <form

     

       53
       53
       -
             hx-post="/knots/register"

     

       70
       70
       +
             hx-post="/settings/knots/register"

     

       54
       71
        
             class="max-w-2xl mb-2 space-y-4"

     

       55
       72
        
             hx-indicator="#register-button"

     

       56
       73
        
             hx-swap="none"

     
···

       84
       101
        
       

     

       85
       102
        
         </section>

     

       86
       103
        
       {{ end }}

     

       104
       104
       +
       

     

       105
       105
       +
       {{ define "docsButton" }}

     

       106
       106
       +
       <a

     

       107
       107
       +
       class="btn flex items-center gap-2"

     

       108
       108
       +
       href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">

     

       109
       109
       +
       {{ i "book" "size-4" }}

     

       110
       110
       +
       docs

     

       111
       111
       +
       </a>

     

       112
       112
       +
       <div

     

       113
       113
       +
       id="add-email-modal"

     

       114
       114
       +
       popover

     

       115
       115
       +
       class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       116
       116
       +
       </div>

     

       117
       117
       +
       {{ end }}

appview/pages/templates/layouts/base.html

···

       9
       9
        
       

     

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

     

       11
       11
        
                   <script defer src="/static/htmx-ext-ws.min.js"></script>

     

       12
       12
       +
                   <script defer src="/static/actor-typeahead.js" type="module"></script>

     

       12
       13
        
       

     

       13
       14
        
                   <!-- preconnect to image cdn -->

     

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

+5 -11

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

···

       15
       15
        
                       {{ with .LoggedInUser }}

     

       16
       16
        
                           {{ block "newButton" . }} {{ end }}

     

       17
       17
        
                           {{ template "notifications/fragments/bell" }}

     

       18
       18
       -
                           {{ block "dropDown" . }} {{ end }}

     

       18
       18
       +
                           {{ block "profileDropdown" . }} {{ end }}

     

       19
       19
        
                       {{ else }}

     

       20
       20
        
                           <a href="/login">login</a>

     

       21
       21
        
                           <span class="text-gray-500 dark:text-gray-400">or</span>

     
···

       33
       33
        
           <summary class="btn-create py-0 cursor-pointer list-none flex items-center gap-2">

     

       34
       34
        
             {{ i "plus" "w-4 h-4" }} <span class="hidden md:inline">new</span>

     

       35
       35
        
           </summary>

     

       36
       36
       -
           <div class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700">

     

       36
       36
       +
           <div class="absolute flex flex-col right-0 mt-3 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700">

     

       37
       37
        
               <a href="/repo/new" class="flex items-center gap-2">

     

       38
       38
        
                 {{ i "book-plus" "w-4 h-4" }}

     

       39
       39
        
                 new repository

     
···

       46
       46
        
       </details>

     

       47
       47
        
       {{ end }}

     

       48
       48
        
       

     

       49
       49
       -
       {{ define "dropDown" }}

     

       49
       49
       +
       {{ define "profileDropdown" }}

     

       50
       50
        
       <details class="relative inline-block text-left nav-dropdown">

     

       51
       51
       -
           <summary

     

       52
       52
       -
               class="cursor-pointer list-none flex items-center gap-1"

     

       53
       53
       -
           >

     

       51
       51
       +
           <summary class="cursor-pointer list-none flex items-center gap-1">

     

       54
       52
        
               {{ $user := .Did }}

     

       55
       53
        
               <img

     

       56
       54
        
                   src="{{ tinyAvatar $user }}"

     
···

       59
       57
        
               />

     

       60
       58
        
               <span class="hidden md:inline">{{ $user | resolve | truncateAt30 }}</span>

     

       61
       59
        
           </summary>

     

       62
       62
       -
           <div

     

       63
       63
       -
               class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700"

     

       64
       64
       -
           >

     

       60
       60
       +
           <div class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700">

     

       65
       61
        
               <a href="/{{ $user }}">profile</a>

     

       66
       62
        
               <a href="/{{ $user }}?tab=repos">repositories</a>

     

       67
       63
        
               <a href="/{{ $user }}?tab=strings">strings</a>

     

       68
       68
       -
               <a href="/knots">knots</a>

     

       69
       69
       -
               <a href="/spindles">spindles</a>

     

       70
       64
        
               <a href="/settings">settings</a>

     

       71
       65
        
               <a href="#"

     

       72
       66
        
                  hx-post="/logout"

+8 -7

appview/pages/templates/layouts/profilebase.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
           {{ $avatarUrl := fullAvatar .Card.UserHandle }}

     

       5
       5
       -
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid }}" />

     

       4
       4
       +
           {{ $handle := resolve .Card.UserDid }}

     

       5
       5
       +
           {{ $avatarUrl := fullAvatar $handle }}

     

       6
       6
       +
           <meta property="og:title" content="{{ $handle }}" />

     

       6
       7
        
           <meta property="og:type" content="profile" />

     

       7
       7
       -
           <meta property="og:url" content="https://tangled.org/{{ or .Card.UserHandle .Card.UserDid }}?tab={{ .Active }}" />

     

       8
       8
       -
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       8
       8
       +
           <meta property="og:url" content="https://tangled.org/{{ $handle }}?tab={{ .Active }}" />

     

       9
       9
       +
           <meta property="og:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       9
       10
        
           <meta property="og:image" content="{{ $avatarUrl }}" />

     

       10
       11
        
           <meta property="og:image:width" content="512" />

     

       11
       12
        
           <meta property="og:image:height" content="512" />

     

       12
       13
        
           

     

       13
       14
        
           <meta name="twitter:card" content="summary" />

     

       14
       14
       -
           <meta name="twitter:title" content="{{ or .Card.UserHandle .Card.UserDid }}" />

     

       15
       15
       -
           <meta name="twitter:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       15
       15
       +
           <meta name="twitter:title" content="{{ $handle }}" />

     

       16
       16
       +
           <meta name="twitter:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       16
       17
        
           <meta name="twitter:image" content="{{ $avatarUrl }}" />

     

       17
       18
        
       {{ end }}

     

       18
       19

+57 -26

appview/pages/templates/layouts/repobase.html

···

       1
       1
        
       {{ define "title" }}{{ .RepoInfo.FullName }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
           <section id="repo-header" class="mb-4 py-2 px-6 dark:text-white">

     

       5
       5
       -
             {{ if .RepoInfo.Source }}

     

       6
       6
       -
             <p class="text-sm">

     

       7
       7
       -
             <div class="flex items-center">

     

       8
       8
       -
                 {{ i "git-fork" "w-3 h-3 mr-1 shrink-0" }}

     

       9
       9
       -
                 forked from

     

       10
       10
       -
                 {{ $sourceOwner := didOrHandle .RepoInfo.Source.Did .RepoInfo.SourceHandle  }}

     

       11
       11
       -
                 <a class="ml-1 underline" href="/{{ $sourceOwner }}/{{ .RepoInfo.Source.Name }}">{{ $sourceOwner }}/{{ .RepoInfo.Source.Name }}</a>

     

       12
       12
       -
             </div>

     

       13
       13
       -
             </p>

     

       14
       14
       -
             {{ end }}

     

       15
       15
       -
             <div class="text-lg flex items-center justify-between">

     

       16
       16
       -
               <div>

     

       17
       17
       -
                 <a href="/{{ .RepoInfo.OwnerWithAt }}">{{ .RepoInfo.OwnerWithAt }}</a>

     

       18
       18
       -
                 <span class="select-none">/</span>

     

       19
       19
       -
                 <a href="/{{ .RepoInfo.FullName }}" class="font-bold">{{ .RepoInfo.Name }}</a>

     

       4
       4
       +
           <section id="repo-header" class="mb-4 p-2 dark:text-white">

     

       5
       5
       +
             <div class="text-lg flex flex-col sm:flex-row items-start gap-4 justify-between">

     

       6
       6
       +
               <!-- left items -->

     

       7
       7
       +
               <div class="flex flex-col gap-2">

     

       8
       8
       +
                 <!-- repo owner / repo name -->

     

       9
       9
       +
                 <div class="flex items-center gap-2 flex-wrap">

     

       10
       10
       +
                   {{ template "user/fragments/picHandleLink" .RepoInfo.OwnerDid }}

     

       11
       11
       +
                   <span class="select-none">/</span>

     

       12
       12
       +
                   <a href="/{{ .RepoInfo.FullName }}" class="font-bold">{{ .RepoInfo.Name }}</a>

     

       13
       13
       +
                 </div>

     

       14
       14
       +
       

     

       15
       15
       +
                 {{ if .RepoInfo.Source }}

     

       16
       16
       +
                   {{ $sourceOwner := resolve .RepoInfo.Source.Did }}

     

       17
       17
       +
                   <div class="flex items-center gap-1 text-sm flex-wrap">

     

       18
       18
       +
                     {{ i "git-fork" "w-3 h-3 shrink-0" }}

     

       19
       19
       +
                     <span>forked from</span>

     

       20
       20
       +
                     <a class="underline" href="/{{ $sourceOwner }}/{{ .RepoInfo.Source.Name }}">

     

       21
       21
       +
                       {{ $sourceOwner }}/{{ .RepoInfo.Source.Name }}

     

       22
       22
       +
                     </a>

     

       23
       23
       +
                   </div>

     

       24
       24
       +
                 {{ end }}

     

       25
       25
       +
       

     

       26
       26
       +
                 <span class="flex flex-wrap items-center gap-x-4 gap-y-2 text-sm text-gray-600 dark:text-gray-300">

     

       27
       27
       +
                   {{ if .RepoInfo.Description }}

     

       28
       28
       +
                     {{ .RepoInfo.Description | description }}

     

       29
       29
       +
                   {{ else }}

     

       30
       30
       +
                     <span class="italic">this repo has no description</span>

     

       31
       31
       +
                   {{ end }}

     

       32
       32
       +
       

     

       33
       33
       +
                   {{ with .RepoInfo.Website }}

     

       34
       34
       +
                     <span class="flex items-center gap-1">

     

       35
       35
       +
                       <span class="flex-shrink-0">{{ i "globe" "size-4" }}</span>

     

       36
       36
       +
                       <a href="{{ . }}">{{ . | trimUriScheme }}</a>

     

       37
       37
       +
                     </span>

     

       38
       38
       +
                   {{ end }}

     

       39
       39
       +
       

     

       40
       40
       +
                   {{ if .RepoInfo.Topics }}

     

       41
       41
       +
                     <div class="flex items-center gap-1 text-sm text-gray-600 dark:text-gray-300">

     

       42
       42
       +
                       {{ range .RepoInfo.Topics }}

     

       43
       43
       +
                         <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 text-sm">{{ . }}</span>

     

       44
       44
       +
                       {{ end }}

     

       45
       45
       +
                     </div>

     

       46
       46
       +
                   {{ end }}

     

       47
       47
       +
       

     

       48
       48
       +
                 </span>

     

       20
       49
        
               </div>

     

       21
       50
        
       

     

       22
       22
       -
               <div class="flex items-center gap-2 z-auto">

     

       23
       23
       -
                 <a

     

       24
       24
       -
                   class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       25
       25
       -
                   href="/{{ .RepoInfo.FullName }}/feed.atom"

     

       26
       26
       -
                 >

     

       27
       27
       -
                   {{ i "rss" "size-4" }}

     

       28
       28
       -
                 </a>

     

       29
       29
       -
                 {{ template "repo/fragments/repoStar" .RepoInfo }}

     

       51
       51
       +
               <div class="w-full sm:w-fit grid grid-cols-3 gap-2 z-auto">

     

       52
       52
       +
                 {{ template "fragments/starBtn"

     

       53
       53
       +
                   (dict "SubjectAt" .RepoInfo.RepoAt

     

       54
       54
       +
                         "IsStarred" .RepoInfo.IsStarred

     

       55
       55
       +
                         "StarCount" .RepoInfo.Stats.StarCount) }}

     

       30
       56
        
                 <a

     

       31
       57
        
                   class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       32
       58
        
                   hx-boost="true"

     
···

       36
       62
        
                   fork

     

       37
       63
        
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       38
       64
        
                 </a>

     

       65
       65
       +
                 <a

     

       66
       66
       +
                   class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       67
       67
       +
                   href="/{{ .RepoInfo.FullName }}/feed.atom">

     

       68
       68
       +
                   {{ i "rss" "size-4" }}

     

       69
       69
       +
                   <span class="md:hidden">atom</span>

     

       70
       70
       +
                 </a>

     

       39
       71
        
               </div>

     

       40
       72
        
             </div>

     

       41
       41
       -
             {{ template "repo/fragments/repoDescription" . }}

     

       42
       73
        
           </section>

     

       43
       74
        
       

     

       44
       75
        
           <section class="w-full flex flex-col" >

     
···

       79
       110
        
                   </div>

     

       80
       111
        
               </nav>

     

       81
       112
        
               {{ block "repoContentLayout" . }}

     

       82
       82
       -
                 <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white">

     

       113
       113
       +
                 <section class="bg-white dark:bg-gray-800 px-6 py-4 rounded relative w-full mx-auto dark:text-white">

     

       83
       114
        
                   {{ block "repoContent" . }}{{ end }}

     

       84
       115
        
                 </section>

     

       85
       116
        
                 {{ block "repoAfter" . }}{{ end }}

appview/pages/templates/notifications/fragments/item.html

···

       40
       40
        
           commented on an issue

     

       41
       41
        
         {{ else if eq .Type "issue_closed" }}

     

       42
       42
        
           closed an issue

     

       43
       43
       +
         {{ else if eq .Type "issue_reopen" }}

     

       44
       44
       +
           reopened an issue

     

       43
       45
        
         {{ else if eq .Type "pull_created" }}

     

       44
       46
        
           created a pull request

     

       45
       47
        
         {{ else if eq .Type "pull_commented" }}

     
···

       48
       50
        
           merged a pull request

     

       49
       51
        
         {{ else if eq .Type "pull_closed" }}

     

       50
       52
        
           closed a pull request

     

       53
       53
       +
         {{ else if eq .Type "pull_reopen" }}

     

       54
       54
       +
           reopened a pull request

     

       51
       55
        
         {{ else if eq .Type "followed" }}

     

       52
       56
        
           followed you

     

       57
       57
       +
         {{ else if eq .Type "user_mentioned" }}

     

       58
       58
       +
           mentioned you

     

       53
       59
        
         {{ else }}

     

       54
       60
        
         {{ end }}

     

       55
       61
        
       {{ end }}

+64 -39

appview/pages/templates/repo/blob.html

···

       11
       11
        
       {{ end }}

     

       12
       12
        
       

     

       13
       13
        
       {{ define "repoContent" }}

     

       14
       14
       -
           {{ $lines := split .Contents }}

     

       15
       15
       -
           {{ $tot_lines := len $lines }}

     

       16
       16
       -
           {{ $tot_chars := len (printf "%d" $tot_lines) }}

     

       17
       17
       -
           {{ $code_number_style := "text-gray-400 dark:text-gray-500 left-0 bg-white dark:bg-gray-800 text-right mr-6 select-none inline-block w-12" }}

     

       18
       14
        
           {{ $linkstyle := "no-underline hover:underline" }}

     

       19
       15
        
           <div class="pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700">

     

       20
       16
        
               <div class="flex flex-col md:flex-row md:justify-between gap-2">

     
···

       36
       32
        
                   </div>

     

       37
       33
        
                   <div id="file-info" class="text-gray-500 dark:text-gray-400 text-xs md:text-sm flex flex-wrap items-center gap-1 md:gap-0">

     

       38
       34
        
                       <span>at <a href="/{{ .RepoInfo.FullName }}/tree/{{ .Ref }}">{{ .Ref }}</a></span>

     

       39
       39
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       40
       40
       -
                       <span>{{ .Lines }} lines</span>

     

       41
       41
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       42
       42
       -
                       <span>{{ byteFmt .SizeHint }}</span>

     

       43
       43
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       44
       44
       -
                       <a href="/{{ .RepoInfo.FullName }}/raw/{{ .Ref }}/{{ .Path }}">view raw</a>

     

       45
       45
       -
                       {{ if .RenderToggle }}

     

       46
       46
       -
                       <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       47
       47
       -
                       <a

     

       48
       48
       -
                       href="/{{ .RepoInfo.FullName }}/blob/{{ .Ref }}/{{ .Path }}?code={{ .ShowRendered }}"

     

       49
       49
       -
                       hx-boost="true"

     

       50
       50
       -
                       >view {{ if .ShowRendered }}code{{ else }}rendered{{ end }}</a>

     

       35
       35
       +
       

     

       36
       36
       +
                       {{ if .BlobView.ShowingText }}

     

       37
       37
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       38
       38
       +
                         <span>{{ .Lines }} lines</span>

     

       39
       39
       +
                       {{ end }}

     

       40
       40
       +
       

     

       41
       41
       +
                       {{ if .BlobView.SizeHint }}

     

       42
       42
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       43
       43
       +
                         <span>{{ byteFmt .BlobView.SizeHint }}</span>

     

       44
       44
       +
                       {{ end }}

     

       45
       45
       +
       

     

       46
       46
       +
                       {{ if .BlobView.HasRawView }}

     

       47
       47
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       48
       48
       +
                         <a href="/{{ .RepoInfo.FullName }}/raw/{{ .Ref }}/{{ .Path }}">view raw</a>

     

       49
       49
       +
                       {{ end }}

     

       50
       50
       +
       

     

       51
       51
       +
                       {{ if .BlobView.ShowToggle }}

     

       52
       52
       +
                         <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     

       53
       53
       +
                         <a href="/{{ .RepoInfo.FullName }}/blob/{{ .Ref }}/{{ .Path }}?code={{ .BlobView.ShowingRendered }}" hx-boost="true">

     

       54
       54
       +
                           view {{ if .BlobView.ShowingRendered }}code{{ else }}rendered{{ end }}

     

       55
       55
       +
                         </a>

     

       51
       56
        
                       {{ end }}

     

       52
       57
        
                   </div>

     

       53
       58
        
               </div>

     

       54
       59
        
           </div>

     

       55
       55
       -
           {{ if and .IsBinary .Unsupported }}

     

       56
       56
       -
               <p class="text-center text-gray-400 dark:text-gray-500">

     

       57
       57
       -
                   Previews are not supported for this file type.

     

       58
       58
       -
               </p>

     

       59
       59
       -
           {{ else if .IsBinary }}

     

       60
       60
       -
               <div class="text-center">

     

       61
       61
       -
                   {{ if .IsImage }}

     

       62
       62
       -
                       <img src="{{ .ContentSrc }}"

     

       63
       63
       -
                            alt="{{ .Path }}"

     

       64
       64
       -
                            class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       65
       65
       -
                   {{ else if .IsVideo }}

     

       66
       66
       -
                       <video controls class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded">

     

       67
       67
       -
                           <source src="{{ .ContentSrc }}">

     

       68
       68
       -
                           Your browser does not support the video tag.

     

       69
       69
       -
                       </video>

     

       70
       70
       -
                   {{ end }}

     

       71
       71
       -
               </div>

     

       72
       72
       -
           {{ else }}

     

       73
       73
       -
           <div class="overflow-auto relative">

     

       74
       74
       -
               {{ if .ShowRendered }}

     

       75
       75
       -
               <div id="blob-contents" class="prose dark:prose-invert">{{ .RenderedContents }}</div>

     

       60
       60
       +
           {{ if .BlobView.IsUnsupported }}

     

       61
       61
       +
             <p class="text-center text-gray-400 dark:text-gray-500">

     

       62
       62
       +
                 Previews are not supported for this file type.

     

       63
       63
       +
             </p>

     

       64
       64
       +
           {{ else if .BlobView.ContentType.IsSubmodule }}

     

       65
       65
       +
             <p class="text-center text-gray-400 dark:text-gray-500">

     

       66
       66
       +
               This directory is a git submodule of <a href="{{ .BlobView.ContentSrc }}">{{ .BlobView.ContentSrc }}</a>.

     

       67
       67
       +
             </p>

     

       68
       68
       +
           {{ else if .BlobView.ContentType.IsImage }}

     

       69
       69
       +
             <div class="text-center">

     

       70
       70
       +
               <img src="{{ .BlobView.ContentSrc }}"

     

       71
       71
       +
                    alt="{{ .Path }}"

     

       72
       72
       +
                    class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       73
       73
       +
             </div>

     

       74
       74
       +
           {{ else if .BlobView.ContentType.IsVideo }}

     

       75
       75
       +
             <div class="text-center">

     

       76
       76
       +
               <video controls class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded">

     

       77
       77
       +
                   <source src="{{ .BlobView.ContentSrc }}">

     

       78
       78
       +
                   Your browser does not support the video tag.

     

       79
       79
       +
               </video>

     

       80
       80
       +
             </div>

     

       81
       81
       +
           {{ else if .BlobView.ContentType.IsSvg }}

     

       82
       82
       +
             <div class="overflow-auto relative">

     

       83
       83
       +
               {{ if .BlobView.ShowingRendered }}

     

       84
       84
       +
                 <div class="text-center">

     

       85
       85
       +
                   <img src="{{ .BlobView.ContentSrc }}"

     

       86
       86
       +
                        alt="{{ .Path }}"

     

       87
       87
       +
                        class="max-w-full h-auto mx-auto border border-gray-200 dark:border-gray-700 rounded" />

     

       88
       88
       +
                 </div>

     

       89
       89
       +
               {{ else }}

     

       90
       90
       +
                 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       91
       91
       +
               {{ end }}

     

       92
       92
       +
             </div>

     

       93
       93
       +
           {{ else if .BlobView.ContentType.IsMarkup }}

     

       94
       94
       +
             <div class="overflow-auto relative">

     

       95
       95
       +
               {{ if .BlobView.ShowingRendered }}

     

       96
       96
       +
                 <div id="blob-contents" class="prose dark:prose-invert">{{ .BlobView.Contents | readme }}</div>

     

       76
       97
        
               {{ else }}

     

       77
       77
       -
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ $.Contents | escapeHtml }}</div>

     

       98
       98
       +
                 <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       78
       99
        
               {{ end }}

     

       79
       79
       -
           </div>

     

       100
       100
       +
             </div>

     

       101
       101
       +
           {{ else if .BlobView.ContentType.IsCode }}

     

       102
       102
       +
             <div class="overflow-auto relative">

     

       103
       103
       +
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .BlobView.Contents .Path | escapeHtml }}</div>

     

       104
       104
       +
             </div>

     

       80
       105
        
           {{ end }}

     

       81
       106
        
           {{ template "fragments/multiline-select" }}

     

       82
       107
        
       {{ end }}

+41 -16

appview/pages/templates/repo/commit.html

···

       24
       24
        
           </div>

     

       25
       25
        
         </div>

     

       26
       26
        
       

     

       27
       27
       -
         <div class="flex items-center space-x-2">

     

       28
       28
       -
             <p class="text-sm text-gray-500 dark:text-gray-300">

     

       29
       29
       -
                 {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       27
       27
       +
         <div class="flex flex-wrap items-center space-x-2">

     

       28
       28
       +
             <p class="flex flex-wrap items-center gap-1 text-sm text-gray-500 dark:text-gray-300">

     

       29
       29
       +
                 {{ template "attribution" . }}

     

       30
       30
        
       

     

       31
       31
       -
                 {{ if $didOrHandle }}

     

       32
       32
       -
                   <a href="/{{ $didOrHandle }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ $didOrHandle }}</a>

     

       33
       33
       -
                 {{ else }}

     

       34
       34
       -
                   <a href="mailto:{{ $commit.Author.Email }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ $commit.Author.Name }}</a>

     

       35
       35
       -
                 {{ end }}

     

       36
       31
        
                 <span class="px-1 select-none before:content-['\00B7']"></span>

     

       37
       37
       -
                 {{ template "repo/fragments/time" $commit.Author.When }}

     

       32
       32
       +
                   {{ template "repo/fragments/time" $commit.Committer.When }}

     

       38
       33
        
                 <span class="px-1 select-none before:content-['\00B7']"></span>

     

       39
       39
       -
             </p>

     

       40
       34
        
       

     

       41
       41
       -
             <p class="flex items-center text-sm text-gray-500 dark:text-gray-300">

     

       42
       35
        
                 <a href="/{{ $repo }}/commit/{{ $commit.This }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ slice $commit.This 0 8 }}</a>

     

       36
       36
       +
       

     

       43
       37
        
                 {{ if $commit.Parent }}

     

       44
       44
       -
                 {{ i "arrow-left" "w-3 h-3 mx-1" }}

     

       45
       45
       -
                 <a href="/{{ $repo }}/commit/{{ $commit.Parent }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ slice $commit.Parent 0 8 }}</a>

     

       38
       38
       +
                   {{ i "arrow-left" "w-3 h-3 mx-1" }}

     

       39
       39
       +
                   <a href="/{{ $repo }}/commit/{{ $commit.Parent }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ slice $commit.Parent 0 8 }}</a>

     

       46
       40
        
                 {{ end }}

     

       47
       41
        
             </p>

     

       48
       42
        
       

     
···

       58
       52
        
                     <div class="mb-1">This commit was signed with the committer's <span class="text-green-600 font-semibold">known signature</span>.</div>

     

       59
       53
        
                     <div class="flex items-center gap-2 my-2">

     

       60
       54
        
                         {{ i "user" "w-4 h-4" }}

     

       61
       61
       -
                         {{ $committerDidOrHandle := index $.EmailToDidOrHandle $commit.Committer.Email }}

     

       62
       62
       -
                         <a href="/{{ $committerDidOrHandle }}">{{ template "user/fragments/picHandleLink" $committerDidOrHandle }}</a>

     

       55
       55
       +
                         {{ $committerDid := index $.EmailToDid $commit.Committer.Email }}

     

       56
       56
       +
                         {{ template "user/fragments/picHandleLink" $committerDid }}

     

       63
       57
        
                     </div>

     

       64
       58
        
                     <div class="my-1 pt-2 text-xs border-t border-gray-200 dark:border-gray-700">

     

       65
       59
        
                         <div class="text-gray-600 dark:text-gray-300">SSH Key Fingerprint:</div>

     
···

       79
       73
        
       </section>

     

       80
       74
        
       {{end}}

     

       81
       75
        
       

     

       76
       76
       +
       {{ define "attribution" }}

     

       77
       77
       +
         {{ $commit := .Diff.Commit }}

     

       78
       78
       +
         {{ $showCommitter := true }}

     

       79
       79
       +
         {{ if eq $commit.Author.Email $commit.Committer.Email }}

     

       80
       80
       +
           {{ $showCommitter = false }}

     

       81
       81
       +
         {{ end }}

     

       82
       82
       +
       

     

       83
       83
       +
         {{ if $showCommitter }}

     

       84
       84
       +
           authored by {{ template "attributedUser" (list $commit.Author.Email $commit.Author.Name $.EmailToDid) }}

     

       85
       85
       +
           {{ range $commit.CoAuthors }} 

     

       86
       86
       +
             {{ template "attributedUser" (list .Email .Name $.EmailToDid) }}

     

       87
       87
       +
           {{ end }}

     

       88
       88
       +
           and committed by  {{ template "attributedUser" (list $commit.Committer.Email $commit.Committer.Name $.EmailToDid) }}

     

       89
       89
       +
         {{ else }}

     

       90
       90
       +
           {{ template "attributedUser" (list $commit.Author.Email $commit.Author.Name $.EmailToDid )}}

     

       91
       91
       +
         {{ end }}

     

       92
       92
       +
       {{ end }}

     

       93
       93
       +
       

     

       94
       94
       +
       {{ define "attributedUser" }}

     

       95
       95
       +
         {{ $email := index . 0 }}

     

       96
       96
       +
         {{ $name := index . 1 }}

     

       97
       97
       +
         {{ $map := index . 2 }}

     

       98
       98
       +
         {{ $did := index $map $email }}

     

       99
       99
       +
       

     

       100
       100
       +
         {{ if $did }}

     

       101
       101
       +
           {{ template "user/fragments/picHandleLink" $did }}

     

       102
       102
       +
         {{ else }}

     

       103
       103
       +
           <a href="mailto:{{ $email }}" class="no-underline hover:underline text-gray-500 dark:text-gray-300">{{ $name }}</a>

     

       104
       104
       +
         {{ end }}

     

       105
       105
       +
       {{ end }}

     

       106
       106
       +
       

     

       82
       107
        
       {{ define "topbarLayout" }}

     

       83
       108
        
         <header class="col-span-full" style="z-index: 20;">

     

       84
       109
        
           {{ template "layouts/fragments/topbar" . }}

     
···

       111
       136
        
       {{ end }}

     

       112
       137
        
       

     

       113
       138
        
       {{ define "contentAfter" }}

     

       114
       114
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       139
       139
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       115
       140
        
       {{end}}

     

       116
       141
        
       

     

       117
       142
        
       {{ define "contentAfterLeft" }}

+2 -2

appview/pages/templates/repo/compare/compare.html

···

       17
       17
        
       {{ end }}

     

       18
       18
        
       

     

       19
       19
        
       {{ define "mainLayout" }}

     

       20
       20
       -
         <div class="px-1 col-span-full flex flex-col gap-4">

     

       20
       20
       +
         <div class="px-1 flex-grow col-span-full flex flex-col gap-4">

     

       21
       21
        
           {{ block "contentLayout" . }}

     

       22
       22
        
             {{ block "content" . }}{{ end }}

     

       23
       23
        
           {{ end }}

     
···

       42
       42
        
       {{ end }}

     

       43
       43
        
       

     

       44
       44
        
       {{ define "contentAfter" }}

     

       45
       45
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       45
       45
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       46
       46
        
       {{end}}

     

       47
       47
        
       

     

       48
       48
        
       {{ define "contentAfterLeft" }}

+1 -1

appview/pages/templates/repo/empty.html

···

       35
       35
        
       

     

       36
       36
        
                 <p><span class="{{$bullet}}">1</span>First, generate a new <a href="https://git-scm.com/book/en/v2/Git-on-the-Server-Generating-Your-SSH-Public-Key" class="underline">SSH key pair</a>.</p>

     

       37
       37
        
                 <p><span class="{{$bullet}}">2</span>Then add the public key to your account from the <a href="/settings" class="underline">settings</a> page.</p>

     

       38
       38
       -
                 <p><span class="{{$bullet}}">3</span>Configure your remote to <code>git@{{ $knot }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code></p>

     

       38
       38
       +
                 <p><span class="{{$bullet}}">3</span>Configure your remote to <code>git@{{ $knot | stripPort }}:{{ resolve .RepoInfo.OwnerDid }}/{{ .RepoInfo.Name }}</code></p>

     

       39
       39
        
                 <p><span class="{{$bullet}}">4</span>Push!</p>

     

       40
       40
        
               </div>

     

       41
       41
        
             </div>

+2 -1

appview/pages/templates/repo/fork.html

···

       25
       25
        
                       value="{{ . }}"

     

       26
       26
        
                       class="mr-2"

     

       27
       27
        
                       id="domain-{{ . }}"

     

       28
       28
       +
                       {{if eq (len $.Knots) 1}}checked{{end}}                

     

       28
       29
        
                       />

     

       29
       30
        
                   <label for="domain-{{ . }}" class="dark:text-white">{{ . }}</label>

     

       30
       31
        
                 </div>

     
···

       33
       34
        
               {{ end }}

     

       34
       35
        
               </div>

     

       35
       36
        
             </div>

     

       36
       36
       -
             <p class="text-sm text-gray-500 dark:text-gray-400">A knot hosts repository data. <a href="/knots" class="underline">Learn how to register your own knot.</a></p>

     

       37
       37
       +
             <p class="text-sm text-gray-500 dark:text-gray-400">A knot hosts repository data. <a href="/settings/knots" class="underline">Learn how to register your own knot.</a></p>

     

       37
       38
        
           </fieldset>

     

       38
       39
        
       

     

       39
       40
        
           <div class="space-y-2">

+49

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

···

       1
       1
       +
       {{ define "repo/fragments/backlinks" }}

     

       2
       2
       +
         {{ if .Backlinks }}

     

       3
       3
       +
         <div id="at-uri-panel" class="px-2 md:px-0">

     

       4
       4
       +
           <div>

     

       5
       5
       +
             <span class="text-sm py-1 font-bold text-gray-500 dark:text-gray-400">Referenced by</span>

     

       6
       6
       +
           </div>

     

       7
       7
       +
           <ul>

     

       8
       8
       +
             {{ range .Backlinks }}

     

       9
       9
       +
             <li>

     

       10
       10
       +
               {{ $repoOwner := resolve .Handle }}

     

       11
       11
       +
               {{ $repoName := .Repo }}

     

       12
       12
       +
               {{ $repoUrl := printf "%s/%s" $repoOwner $repoName }}

     

       13
       13
       +
               <div class="flex flex-col">

     

       14
       14
       +
                 <div class="flex gap-2 items-center">

     

       15
       15
       +
                   {{ if .State.IsClosed }}

     

       16
       16
       +
                     <span class="text-gray-500 dark:text-gray-400">

     

       17
       17
       +
                       {{ i "ban" "w-4 h-4" }}

     

       18
       18
       +
                     </span>

     

       19
       19
       +
                   {{ else if eq .Kind.String "issues" }}

     

       20
       20
       +
                     <span class="text-green-600 dark:text-green-500">

     

       21
       21
       +
                       {{ i "circle-dot" "w-4 h-4" }}

     

       22
       22
       +
                     </span>

     

       23
       23
       +
                   {{ else if .State.IsOpen }}

     

       24
       24
       +
                     <span class="text-green-600 dark:text-green-500">

     

       25
       25
       +
                       {{ i "git-pull-request" "w-4 h-4" }}

     

       26
       26
       +
                     </span>

     

       27
       27
       +
                   {{ else if .State.IsMerged }}

     

       28
       28
       +
                     <span class="text-purple-600 dark:text-purple-500">

     

       29
       29
       +
                       {{ i "git-merge" "w-4 h-4" }}

     

       30
       30
       +
                     </span>

     

       31
       31
       +
                   {{ else }}

     

       32
       32
       +
                     <span class="text-gray-600 dark:text-gray-300">

     

       33
       33
       +
                       {{ i "git-pull-request-closed" "w-4 h-4" }}

     

       34
       34
       +
                     </span>

     

       35
       35
       +
                   {{ end }}

     

       36
       36
       +
                   <a href="{{ . }}"><span class="text-gray-500 dark:text-gray-400">#{{ .SubjectId }}</span> {{ .Title }}</a>

     

       37
       37
       +
                 </div>

     

       38
       38
       +
                 {{ if not (eq $.RepoInfo.FullName $repoUrl) }}

     

       39
       39
       +
                 <div>

     

       40
       40
       +
                   <span>on <a href="/{{ $repoUrl }}">{{ $repoUrl }}</a></span>

     

       41
       41
       +
                 </div>

     

       42
       42
       +
                 {{ end }}

     

       43
       43
       +
               </div>

     

       44
       44
       +
             </li>

     

       45
       45
       +
             {{ end }}

     

       46
       46
       +
           </ul>

     

       47
       47
       +
         </div>

     

       48
       48
       +
         {{ end }}

     

       49
       49
       +
       {{ end }}

+5 -4

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

···

       29
       29
        
                               <code

     

       30
       30
        
                                   class="flex-1 px-3 py-2 text-sm bg-gray-50 dark:bg-gray-700 text-gray-900 dark:text-gray-100 rounded-l select-all cursor-pointer whitespace-nowrap overflow-x-auto"

     

       31
       31
        
                                   onclick="window.getSelection().selectAllChildren(this)"

     

       32
       32
       -
                                   data-url="https://tangled.org/{{ .RepoInfo.OwnerWithAt }}/{{ .RepoInfo.Name }}"

     

       33
       33
       -
                               >https://tangled.org/{{ .RepoInfo.OwnerWithAt }}/{{ .RepoInfo.Name }}</code>

     

       32
       32
       +
                                   data-url="https://tangled.org/{{ resolve .RepoInfo.OwnerDid }}/{{ .RepoInfo.Name }}"

     

       33
       33
       +
                               >https://tangled.org/{{ resolve .RepoInfo.OwnerDid }}/{{ .RepoInfo.Name }}</code>

     

       34
       34
        
                               <button

     

       35
       35
        
                                   onclick="copyToClipboard(this, this.previousElementSibling.getAttribute('data-url'))"

     

       36
       36
        
                                   class="px-3 py-2 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 border-l border-gray-300 dark:border-gray-600"

     
···

       43
       43
        
       

     

       44
       44
        
                       <!-- SSH Clone -->

     

       45
       45
        
                       <div class="mb-3">

     

       46
       46
       +
                           {{ $repoOwnerHandle := resolve .RepoInfo.OwnerDid }}

     

       46
       47
        
                           <label class="block text-xs font-medium text-gray-700 dark:text-gray-300 mb-1">SSH</label>

     

       47
       48
        
                           <div class="flex items-center border border-gray-300 dark:border-gray-600 rounded">

     

       48
       49
        
                               <code

     

       49
       50
        
                                   class="flex-1 px-3 py-2 text-sm bg-gray-50 dark:bg-gray-700 text-gray-900 dark:text-gray-100 rounded-l select-all cursor-pointer whitespace-nowrap overflow-x-auto"

     

       50
       51
        
                                   onclick="window.getSelection().selectAllChildren(this)"

     

       51
       51
       -
                                   data-url="git@{{ $knot }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}"

     

       52
       52
       -
                               >git@{{ $knot }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code>

     

       52
       52
       +
                                   data-url="git@{{ $knot | stripPort }}:{{ $repoOwnerHandle }}/{{ .RepoInfo.Name }}"

     

       53
       53
       +
                               >git@{{ $knot | stripPort }}:{{ $repoOwnerHandle }}/{{ .RepoInfo.Name }}</code>

     

       53
       54
        
                               <button

     

       54
       55
        
                                   onclick="copyToClipboard(this, this.previousElementSibling.getAttribute('data-url'))"

     

       55
       56
        
                                   class="px-3 py-2 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 border-l border-gray-300 dark:border-gray-600"

+2 -3

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

···

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

     

       2
       2
       -
         {{ $repo := index . 0 }}

     

       3
       3
       -
         {{ $diff := index . 1 }}

     

       4
       4
       -
         {{ $opts := index . 2 }}

     

       2
       2
       +
         {{ $diff := index . 0 }}

     

       3
       3
       +
         {{ $opts := index . 1 }}

     

       5
       4
        
       

     

       6
       5
        
         {{ $commit := $diff.Commit }}

     

       7
       6
        
         {{ $diff := $diff.Diff }}

+20 -18

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

···

       5
       5
        
           {{ if .Split }}

     

       6
       6
        
             {{ $active = "split" }}

     

       7
       7
        
           {{ end }}

     

       8
       8
       -
           {{ $values := list "unified" "split" }}

     

       9
       9
       -
           {{ block "tabSelector" (dict "Name" "diff" "Values" $values "Active" $active) }} {{ end }}

     

       8
       8
       +
       

     

       9
       9
       +
           {{ $unified := 

     

       10
       10
       +
              (dict

     

       11
       11
       +
                "Key" "unified"

     

       12
       12
       +
                "Value" "unified"

     

       13
       13
       +
                "Icon" "square-split-vertical"

     

       14
       14
       +
                "Meta" "") }}

     

       15
       15
       +
           {{ $split := 

     

       16
       16
       +
              (dict

     

       17
       17
       +
                "Key" "split"

     

       18
       18
       +
                "Value" "split"

     

       19
       19
       +
                "Icon" "square-split-horizontal"

     

       20
       20
       +
                "Meta" "") }}

     

       21
       21
       +
           {{ $values := list $unified $split }}

     

       22
       22
       +
       

     

       23
       23
       +
           {{ template "fragments/tabSelector" 

     

       24
       24
       +
              (dict

     

       25
       25
       +
                "Name" "diff"

     

       26
       26
       +
                "Values" $values

     

       27
       27
       +
                "Active" $active) }}

     

       10
       28
        
         </section>

     

       11
       29
        
       {{ end }}

     

       12
       30
        
       

     

       13
       13
       -
       {{ define "tabSelector" }}

     

       14
       14
       -
         {{ $name := .Name }}

     

       15
       15
       -
         {{ $all := .Values }}

     

       16
       16
       -
         {{ $active := .Active }}

     

       17
       17
       -
         <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden">

     

       18
       18
       -
           {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }}

     

       19
       19
       -
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }}

     

       20
       20
       -
           {{ range $index, $value := $all }}

     

       21
       21
       -
             {{ $isActive := eq $value $active }}

     

       22
       22
       -
             <a href="?{{ $name }}={{ $value }}"

     

       23
       23
       -
                class="py-2 text-sm w-full block hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       24
       24
       -
              {{ $value }}

     

       25
       25
       -
             </a>

     

       26
       26
       -
           {{ end }}

     

       27
       27
       -
         </div>

     

       28
       28
       -
       {{ end }}

+15 -1

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

···

       170
       170
        
         {{ $fieldName := $def.AtUri }}

     

       171
       171
        
         {{ $valueType := $def.ValueType }}

     

       172
       172
        
         {{ $value := .value }}

     

       173
       173
       +
       

     

       173
       174
        
         {{ if $valueType.IsDidFormat }}

     

       174
       175
        
           {{ $value = trimPrefix (resolve .value) "@" }}

     

       176
       176
       +
           <actor-typeahead>

     

       177
       177
       +
             <input

     

       178
       178
       +
               autocapitalize="none"

     

       179
       179
       +
               autocorrect="off"

     

       180
       180
       +
               autocomplete="off"

     

       181
       181
       +
               placeholder="user.tngl.sh"

     

       182
       182
       +
               value="{{$value}}"

     

       183
       183
       +
               name="{{$fieldName}}"

     

       184
       184
       +
               type="text"

     

       185
       185
       +
               class="p-1 w-full text-sm"

     

       186
       186
       +
             />

     

       187
       187
       +
           </actor-typeahead>

     

       188
       188
       +
         {{ else }}

     

       189
       189
       +
           <input class="p-1 w-full" type="text" name="{{$fieldName}}" value="{{$value}}">

     

       175
       190
        
         {{ end }}

     

       176
       176
       -
         <input class="p-1 w-full" type="text" name="{{$fieldName}}" value="{{$value}}">

     

       177
       191
        
       {{ end }}

     

       178
       192
        
       

     

       179
       193
        
       {{ define "nullTypeInput" }}

-11

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

···

       1
       1
       -
       {{ define "repo/fragments/editRepoDescription" }}

     

       2
       2
       -
       <form hx-put="/{{ .RepoInfo.FullName }}/description" hx-target="this" hx-swap="outerHTML" class="flex flex-wrap gap-2">

     

       3
       3
       -
           <input type="text" class="p-1" name="description" value="{{ .RepoInfo.Description }}">

     

       4
       4
       -
           <button type="submit" class="btn p-1 flex items-center gap-2 no-underline text-sm">

     

       5
       5
       -
             {{ i "check" "w-3 h-3" }} save 

     

       6
       6
       -
           </button>

     

       7
       7
       -
           <button type="button" class="btn p-1 flex items-center gap-2 no-underline text-sm" hx-get="/{{ .RepoInfo.FullName }}/description" >

     

       8
       8
       -
             {{ i "x" "w-3 h-3" }} cancel 

     

       9
       9
       -
           </button>

     

       10
       10
       -
       </form>

     

       11
       11
       -
       {{ end }}

+48

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

···

       1
       1
       +
       {{ define "repo/fragments/externalLinkPanel" }}

     

       2
       2
       +
         <div id="at-uri-panel" class="px-2 md:px-0">

     

       3
       3
       +
           <div class="flex justify-between items-center gap-2">

     

       4
       4
       +
             <span class="text-sm py-1 font-bold text-gray-500 dark:text-gray-400 capitalize">AT URI</span>

     

       5
       5
       +
             <div class="flex items-center gap-2">

     

       6
       6
       +
               <button

     

       7
       7
       +
                 onclick="copyToClipboard(this)"

     

       8
       8
       +
                 class="text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200"

     

       9
       9
       +
                 title="Copy to clipboard">

     

       10
       10
       +
                 {{ i "copy" "w-4 h-4" }}

     

       11
       11
       +
               </button>

     

       12
       12
       +
               <a

     

       13
       13
       +
                 href="https://pdsls.dev/{{.}}"

     

       14
       14
       +
                 class="text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200"

     

       15
       15
       +
                 title="View in PDSls">

     

       16
       16
       +
                 {{ i "arrow-up-right" "w-4 h-4" }}

     

       17
       17
       +
               </a>

     

       18
       18
       +
             </div>

     

       19
       19
       +
           </div>

     

       20
       20
       +
           <span

     

       21
       21
       +
             class="font-mono text-sm select-all cursor-pointer block max-w-full overflow-x-auto whitespace-nowrap scrollbar-thin scrollbar-thumb-gray-300 dark:scrollbar-thumb-gray-600"

     

       22
       22
       +
             onclick="window.getSelection().selectAllChildren(this)"

     

       23
       23
       +
             title="{{.}}"

     

       24
       24
       +
             data-aturi="{{ . | string | safeUrl }}"

     

       25
       25
       +
             >{{.}}</span>

     

       26
       26
       +
       

     

       27
       27
       +
       

     

       28
       28
       +
         </div>

     

       29
       29
       +
       

     

       30
       30
       +
         <script>

     

       31
       31
       +
           function copyToClipboard(button) {

     

       32
       32
       +
             const container = document.getElementById("at-uri-panel");

     

       33
       33
       +
             const urlSpan = container?.querySelector('[data-aturi]');

     

       34
       34
       +
             const text = urlSpan?.getAttribute('data-aturi');

     

       35
       35
       +
             console.log("copying to clipboard", text)

     

       36
       36
       +
             if (!text) return;

     

       37
       37
       +
       

     

       38
       38
       +
             navigator.clipboard.writeText(text).then(() => {

     

       39
       39
       +
               const originalContent = button.innerHTML;

     

       40
       40
       +
               button.innerHTML = `{{ i "check" "w-4 h-4" }}`;

     

       41
       41
       +
               setTimeout(() => {

     

       42
       42
       +
                 button.innerHTML = originalContent;

     

       43
       43
       +
               }, 2000);

     

       44
       44
       +
             });

     

       45
       45
       +
           }

     

       46
       46
       +
         </script>

     

       47
       47
       +
       {{ end }}

     

       48
       48
       +

+1 -16

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

···

       6
       6
        
             <span class="font-bold text-gray-500 dark:text-gray-400 capitalize">Participants</span>

     

       7
       7
        
             <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 ml-1">{{ len $all }}</span>

     

       8
       8
        
           </div>

     

       9
       9
       -
           <div class="flex items-center -space-x-3 mt-2">

     

       10
       10
       -
             {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       11
       11
       -
             {{ range $i, $p := $ps }}

     

       12
       12
       -
               <img

     

       13
       13
       -
                   src="{{ tinyAvatar . }}"

     

       14
       14
       -
                   alt=""

     

       15
       15
       -
                   class="rounded-full h-8 w-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0"

     

       16
       16
       -
               />

     

       17
       17
       -
             {{ end }}

     

       18
       18
       -
       

     

       19
       19
       -
             {{ if gt (len $all) 5 }}

     

       20
       20
       -
               <span class="pl-4 text-gray-500 dark:text-gray-400 text-sm">

     

       21
       21
       -
                 +{{ sub (len $all) 5 }}

     

       22
       22
       -
               </span>

     

       23
       23
       -
             {{ end }}

     

       24
       24
       -
           </div>

     

       9
       9
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "w-8 h-8") }}

     

       25
       10
        
         </div>

     

       26
       11
        
       {{ end }}

-15

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

···

       1
       1
       -
       {{ define "repo/fragments/repoDescription" }}

     

       2
       2
       -
       <span id="repo-description" class="flex flex-wrap items-center gap-2 text-sm" hx-target="this" hx-swap="outerHTML">

     

       3
       3
       -
           {{ if .RepoInfo.Description }}

     

       4
       4
       -
               {{ .RepoInfo.Description | description }}

     

       5
       5
       -
           {{ else }}

     

       6
       6
       -
               <span class="italic">this repo has no description</span>

     

       7
       7
       -
           {{ end }}

     

       8
       8
       -
       

     

       9
       9
       -
           {{ if .RepoInfo.Roles.IsOwner }}

     

       10
       10
       -
           <button class="flex items-center gap-2 no-underline text-sm" hx-get="/{{ .RepoInfo.FullName }}/description/edit">

     

       11
       11
       -
             {{ i "pencil" "w-3 h-3" }}

     

       12
       12
       -
           </button>

     

       13
       13
       -
           {{ end }}

     

       14
       14
       -
       </span>

     

       15
       15
       -
       {{ end }}

-26

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

···

       1
       1
       -
       {{ define "repo/fragments/repoStar" }}

     

       2
       2
       -
           <button

     

       3
       3
       -
               id="starBtn"

     

       4
       4
       -
               class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       5
       -
               {{ if .IsStarred }}

     

       6
       6
       -
                   hx-delete="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       7
       7
       -
               {{ else }}

     

       8
       8
       -
                   hx-post="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       9
       9
       -
               {{ end }}

     

       10
       10
       -
       

     

       11
       11
       -
               hx-trigger="click"

     

       12
       12
       -
               hx-target="this"

     

       13
       13
       -
               hx-swap="outerHTML"

     

       14
       14
       -
               hx-disabled-elt="#starBtn"

     

       15
       15
       -
           >

     

       16
       16
       -
               {{ if .IsStarred }}

     

       17
       17
       -
                   {{ i "star" "w-4 h-4 fill-current" }}

     

       18
       18
       -
               {{ else }}

     

       19
       19
       -
                   {{ i "star" "w-4 h-4" }}

     

       20
       20
       -
               {{ end }}

     

       21
       21
       -
               <span class="text-sm">

     

       22
       22
       -
                   {{ .Stats.StarCount }}

     

       23
       23
       -
               </span>

     

       24
       24
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       25
       25
       -
           </button>

     

       26
       26
       -
       {{ end }}

+39 -20

appview/pages/templates/repo/index.html

···

       14
       14
        
               {{ end }}

     

       15
       15
        
               <div class="flex items-center justify-between pb-5">

     

       16
       16
        
                 {{ block "branchSelector" . }}{{ end }}

     

       17
       17
       -
                 <div class="flex md:hidden items-center gap-2">

     

       17
       17
       +
                 <div class="flex md:hidden items-center gap-3">

     

       18
       18
        
                   <a href="/{{ .RepoInfo.FullName }}/commits/{{ .Ref | urlquery }}" class="inline-flex items-center text-sm gap-1 font-bold">

     

       19
       19
        
                     {{ i "git-commit-horizontal" "w-4" "h-4" }} {{ .TotalCommits }}

     

       20
       20
        
                   </a>

     
···

       35
       35
        
       {{ end }}

     

       36
       36
        
       

     

       37
       37
        
       {{ define "repoLanguages" }}

     

       38
       38
       -
           <details class="group -m-6 mb-4">

     

       38
       38
       +
           <details class="group -my-4 -m-6 mb-4">

     

       39
       39
        
             <summary class="flex gap-[1px] h-4 scale-y-50 hover:scale-y-100 origin-top group-open:scale-y-100 transition-all hover:cursor-pointer overflow-hidden rounded-t">

     

       40
       40
        
               {{ range $value := .Languages }}

     

       41
       41
        
               <div

     
···

       47
       47
        
             <div class="px-4 py-2 border-b border-gray-200 dark:border-gray-600 flex items-center gap-4 flex-wrap">

     

       48
       48
        
               {{ range $value := .Languages }}

     

       49
       49
        
               <div

     

       50
       50
       -
                 class="flex flex-grow items-center gap-2 text-xs align-items-center justify-center"

     

       50
       50
       +
                 class="flex items-center gap-2 text-xs align-items-center justify-center"

     

       51
       51
        
               >

     

       52
       52
        
                 {{ template "repo/fragments/colorBall" (dict "color" (langColor $value.Name)) }}

     

       53
       53
        
                 <div>{{ or $value.Name "Other" }}

     
···

       66
       66
        
       

     

       67
       67
        
       {{ define "branchSelector" }}

     

       68
       68
        
         <div class="flex gap-2 items-center justify-between w-full">

     

       69
       69
       -
           <div class="flex gap-2 items-center">

     

       69
       69
       +
           <div class="flex gap-2 items-stretch">

     

       70
       70
        
             <select

     

       71
       71
        
                 onchange="window.location.href = '/{{ .RepoInfo.FullName }}/tree/' + encodeURIComponent(this.value)"

     

       72
       72
        
                 class="p-1 border max-w-32 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700"

     
···

       129
       129
        
                 {{ $icon := "folder" }}

     

       130
       130
        
                 {{ $iconStyle := "size-4 fill-current" }}

     

       131
       131
        
       

     

       132
       132
       +
                 {{ if .IsSubmodule }}

     

       133
       133
       +
                   {{ $link = printf "/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) .Name }}

     

       134
       134
       +
                   {{ $icon = "folder-input" }}

     

       135
       135
       +
                   {{ $iconStyle = "size-4" }}

     

       136
       136
       +
                 {{ end }}

     

       137
       137
       +
       

     

       132
       138
        
                 {{ if .IsFile }}

     

       133
       139
        
                   {{ $link = printf "/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) .Name }}

     

       134
       140
        
                   {{ $icon = "file" }}

     

       135
       141
        
                   {{ $iconStyle = "size-4" }}

     

       136
       142
        
                 {{ end }}

     

       143
       143
       +
       

     

       137
       144
        
                 <a href="{{ $link }}" class="{{ $linkstyle }}">

     

       138
       145
        
                   <div class="flex items-center gap-2">

     

       139
       146
        
                     {{ i $icon $iconStyle "flex-shrink-0" }}

     
···

       221
       228
        
               <span

     

       222
       229
        
                 class="mx-1 before:content-['·'] before:select-none"

     

       223
       230
        
                 ></span>

     

       224
       224
       -
               <span>

     

       225
       225
       -
                 {{ $didOrHandle := index $.EmailToDidOrHandle .Author.Email }}

     

       226
       226
       -
                 <a

     

       227
       227
       -
                   href="{{ if $didOrHandle }}

     

       228
       228
       -
                   /{{ $didOrHandle }}

     

       229
       229
       -
                   {{ else }}

     

       230
       230
       -
                   mailto:{{ .Author.Email }}

     

       231
       231
       -
                   {{ end }}"

     

       232
       232
       -
                   class="text-gray-500 dark:text-gray-400 no-underline hover:underline"

     

       233
       233
       -
                   >{{ if $didOrHandle }}

     

       234
       234
       -
                   {{ template "user/fragments/picHandleLink" $didOrHandle }}

     

       235
       235
       -
                   {{ else }}

     

       236
       236
       -
                   {{ .Author.Name }}

     

       237
       237
       -
                   {{ end }}</a

     

       238
       238
       -
                 >

     

       239
       239
       -
               </span>

     

       231
       231
       +
               {{ template "attribution" (list . $.EmailToDid) }}

     

       240
       232
        
               <div class="inline-block px-1 select-none after:content-['·']"></div>

     

       241
       233
        
               {{ template "repo/fragments/time" .Committer.When }}

     

       242
       234
        
       

     
···

       262
       254
        
           {{ end }}

     

       263
       255
        
         </div>

     

       264
       256
        
       </div>

     

       257
       257
       +
       {{ end }}

     

       258
       258
       +
       

     

       259
       259
       +
       {{ define "attribution" }}

     

       260
       260
       +
         {{ $commit := index . 0 }}

     

       261
       261
       +
         {{ $map := index . 1 }}

     

       262
       262
       +
         <span class="flex items-center">

     

       263
       263
       +
           {{ $author := index $map $commit.Author.Email }}

     

       264
       264
       +
           {{ $coauthors := $commit.CoAuthors }}

     

       265
       265
       +
           {{ $all := list }}

     

       266
       266
       +
       

     

       267
       267
       +
           {{ if $author }}

     

       268
       268
       +
               {{ $all = append $all $author }}

     

       269
       269
       +
           {{ end }}

     

       270
       270
       +
           {{ range $coauthors }}

     

       271
       271
       +
             {{ $co := index $map .Email }}

     

       272
       272
       +
             {{ if $co }}

     

       273
       273
       +
               {{ $all = append $all $co }}

     

       274
       274
       +
             {{ end }}

     

       275
       275
       +
           {{ end }}

     

       276
       276
       +
       

     

       277
       277
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "size-6") }}

     

       278
       278
       +
           <a href="{{ if $author }}/{{ $author }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       279
       279
       +
              class="no-underline hover:underline">

     

       280
       280
       +
              {{ if $author }}{{ resolve $author }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       281
       281
       +
              {{ if $coauthors }} +{{ length $coauthors }}{{ end }}

     

       282
       282
       +
           </a>

     

       283
       283
       +
         </span>

     

       265
       284
        
       {{ end }}

     

       266
       285
        
       

     

       267
       286
        
       {{ define "branchList" }}

+4 -4

appview/pages/templates/repo/issues/fragments/issueCommentHeader.html

···

       19
       19
        
       {{ end }}

     

       20
       20
        
       

     

       21
       21
        
       {{ define "timestamp" }}

     

       22
       22
       -
         <a href="#{{ .Comment.Id }}"

     

       22
       22
       +
         <a href="#comment-{{ .Comment.Id }}"

     

       23
       23
        
            class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline"

     

       24
       24
       -
            id="{{ .Comment.Id }}">

     

       24
       24
       +
            id="comment-{{ .Comment.Id }}">

     

       25
       25
        
           {{ if .Comment.Deleted }}

     

       26
       26
        
             {{ template "repo/fragments/shortTimeAgo" .Comment.Deleted }}

     

       27
       27
        
           {{ else if .Comment.Edited }}

     
···

       34
       34
        
       

     

       35
       35
        
       {{ define "editIssueComment" }}

     

       36
       36
        
         <a

     

       37
       37
       -
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group"

     

       37
       37
       +
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group cursor-pointer"

     

       38
       38
        
           hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/edit"

     

       39
       39
        
           hx-swap="outerHTML"

     

       40
       40
        
           hx-target="#comment-body-{{.Comment.Id}}">

     
···

       44
       44
        
       

     

       45
       45
        
       {{ define "deleteIssueComment" }}

     

       46
       46
        
         <a

     

       47
       47
       -
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group"

     

       47
       47
       +
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group cursor-pointer"

     

       48
       48
        
           hx-delete="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/"

     

       49
       49
        
           hx-confirm="Are you sure you want to delete your comment?"

     

       50
       50
        
           hx-swap="outerHTML"

+1 -1

appview/pages/templates/repo/issues/fragments/issueListing.html

···

       8
       8
        
                   class="no-underline hover:underline"

     

       9
       9
        
                   >

     

       10
       10
        
                   {{ .Title | description }}

     

       11
       11
       -
                   <span class="text-gray-500">#{{ .IssueId }}</span>

     

       11
       11
       +
                   <span class="text-gray-500 dark:text-gray-400">#{{ .IssueId }}</span>

     

       12
       12
        
               </a>

     

       13
       13
        
             </div>

     

       14
       14
        
             <div class="text-sm text-gray-500 dark:text-gray-400 flex flex-wrap items-center gap-1">

+6 -2

appview/pages/templates/repo/issues/issue.html

···

       20
       20
        
                     "Subject" $.Issue.AtUri

     

       21
       21
        
                     "State" $.Issue.Labels) }}

     

       22
       22
        
             {{ template "repo/fragments/participants" $.Issue.Participants }}

     

       23
       23
       +
             {{ template "repo/fragments/backlinks"

     

       24
       24
       +
               (dict "RepoInfo" $.RepoInfo

     

       25
       25
       +
                     "Backlinks" $.Backlinks) }}

     

       26
       26
       +
             {{ template "repo/fragments/externalLinkPanel" $.Issue.AtUri }}

     

       23
       27
        
           </div>

     

       24
       28
        
         </div>

     

       25
       29
        
       {{ end }}

     
···

       84
       88
        
       

     

       85
       89
        
       {{ define "editIssue" }}

     

       86
       90
        
         <a

     

       87
       87
       -
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group"

     

       91
       91
       +
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group cursor-pointer"

     

       88
       92
        
           hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/edit"

     

       89
       93
        
           hx-swap="innerHTML"

     

       90
       94
        
           hx-target="#issue-{{.Issue.IssueId}}">

     
···

       94
       98
        
       

     

       95
       99
        
       {{ define "deleteIssue" }}

     

       96
       100
        
         <a

     

       97
       97
       -
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group"

     

       101
       101
       +
           class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group cursor-pointer"

     

       98
       102
        
           hx-delete="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/"

     

       99
       103
        
           hx-confirm="Are you sure you want to delete your issue?"

     

       100
       104
        
           hx-swap="none">

+147 -47

appview/pages/templates/repo/issues/issues.html

···

       8
       8
        
       {{ end }}

     

       9
       9
        
       

     

       10
       10
        
       {{ define "repoContent" }}

     

       11
       11
       -
       <div class="flex justify-between items-center gap-4">

     

       12
       12
       -
         <div class="flex gap-4">

     

       13
       13
       -
           <a

     

       14
       14
       -
               href="?state=open"

     

       15
       15
       -
               class="flex items-center gap-2 {{ if .FilteringByOpen }}font-bold {{ else }}text-gray-500 dark:text-gray-400{{ end }}"

     

       11
       11
       +
         {{ $active := "closed" }}

     

       12
       12
       +
         {{ if .FilteringByOpen }}

     

       13
       13
       +
           {{ $active = "open" }}

     

       14
       14
       +
         {{ end }}

     

       15
       15
       +
       

     

       16
       16
       +
         {{ $open := 

     

       17
       17
       +
            (dict

     

       18
       18
       +
              "Key" "open"

     

       19
       19
       +
              "Value" "open"

     

       20
       20
       +
              "Icon" "circle-dot"

     

       21
       21
       +
              "Meta" (string .RepoInfo.Stats.IssueCount.Open)) }}

     

       22
       22
       +
         {{ $closed := 

     

       23
       23
       +
            (dict

     

       24
       24
       +
              "Key" "closed"

     

       25
       25
       +
              "Value" "closed"

     

       26
       26
       +
              "Icon" "ban"

     

       27
       27
       +
              "Meta" (string .RepoInfo.Stats.IssueCount.Closed)) }}

     

       28
       28
       +
         {{ $values := list $open $closed }}

     

       29
       29
       +
       

     

       30
       30
       +
         <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2">

     

       31
       31
       +
           <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET">

     

       32
       32
       +
             <input type="hidden" name="state" value="{{ if .FilteringByOpen }}open{{ else }}closed{{ end }}">

     

       33
       33
       +
             <div class="flex-1 flex relative">

     

       34
       34
       +
               <input

     

       35
       35
       +
                 id="search-q"

     

       36
       36
       +
                 class="flex-1 py-1 pl-2 pr-10 mr-[-1px] rounded-r-none focus:border-0 focus:outline-none focus:ring focus:ring-blue-400 ring-inset peer"

     

       37
       37
       +
                 type="text"

     

       38
       38
       +
                 name="q"

     

       39
       39
       +
                 value="{{ .FilterQuery }}"

     

       40
       40
       +
                 placeholder=" "

     

       16
       41
        
               >

     

       17
       17
       -
               {{ i "circle-dot" "w-4 h-4" }}

     

       18
       18
       -
               <span>{{ .RepoInfo.Stats.IssueCount.Open }} open</span>

     

       19
       19
       -
           </a>

     

       42
       42
       +
               <a

     

       43
       43
       +
                 href="?state={{ if .FilteringByOpen }}open{{ else }}closed{{ end }}"

     

       44
       44
       +
                 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block"

     

       45
       45
       +
               >

     

       46
       46
       +
                 {{ i "x" "w-4 h-4" }}

     

       47
       47
       +
               </a>

     

       48
       48
       +
             </div>

     

       49
       49
       +
             <button

     

       50
       50
       +
               type="submit"

     

       51
       51
       +
               class="p-2 text-gray-400 border rounded-r border-gray-400 dark:border-gray-600"

     

       52
       52
       +
             >

     

       53
       53
       +
               {{ i "search" "w-4 h-4" }}

     

       54
       54
       +
             </button>

     

       55
       55
       +
           </form>

     

       56
       56
       +
           <div class="sm:row-start-1">

     

       57
       57
       +
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }}

     

       58
       58
       +
           </div>

     

       20
       59
        
           <a

     

       21
       21
       -
               href="?state=closed"

     

       22
       22
       -
               class="flex items-center gap-2 {{ if not .FilteringByOpen }}font-bold {{ else }}text-gray-500 dark:text-gray-400{{ end }}"

     

       23
       23
       -
               >

     

       24
       24
       -
               {{ i "ban" "w-4 h-4" }}

     

       25
       25
       -
               <span>{{ .RepoInfo.Stats.IssueCount.Closed }} closed</span>

     

       26
       26
       -
           </a>

     

       27
       27
       -
         </div>

     

       28
       28
       -
         <a

     

       29
       60
        
             href="/{{ .RepoInfo.FullName }}/issues/new"

     

       30
       30
       -
             class="btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white"

     

       31
       31
       -
             >

     

       61
       61
       +
             class="col-start-3 btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white"

     

       62
       62
       +
           >

     

       32
       63
        
             {{ i "circle-plus" "w-4 h-4" }}

     

       33
       64
        
             <span>new</span>

     

       34
       34
       -
         </a>

     

       35
       35
       -
       </div>

     

       36
       36
       -
       <div class="error" id="issues"></div>

     

       65
       65
       +
           </a>

     

       66
       66
       +
         </div>

     

       67
       67
       +
         <div class="error" id="issues"></div>

     

       37
       68
        
       {{ end }}

     

       38
       69
        
       

     

       39
       70
        
       {{ define "repoAfter" }}

     

       40
       71
        
         <div class="mt-2">

     

       41
       72
        
           {{ template "repo/issues/fragments/issueListing" (dict "Issues" .Issues "RepoPrefix" .RepoInfo.FullName "LabelDefs" .LabelDefs) }}

     

       42
       73
        
         </div>

     

       43
       43
       -
         {{ block "pagination" . }} {{ end }}

     

       74
       74
       +
         {{if gt .IssueCount .Page.Limit }} 

     

       75
       75
       +
           {{ block "pagination" . }} {{ end }} 

     

       76
       76
       +
         {{ end }}

     

       44
       77
        
       {{ end }}

     

       45
       78
        
       

     

       46
       79
        
       {{ define "pagination" }}

     

       47
       47
       -
       <div class="flex justify-end mt-4 gap-2">

     

       48
       48
       -
           {{ $currentState := "closed" }}

     

       49
       49
       -
           {{ if .FilteringByOpen }}

     

       50
       50
       -
             {{ $currentState = "open" }}

     

       51
       51
       -
           {{ end }}

     

       80
       80
       +
       <div class="flex justify-center items-center mt-4 gap-2">

     

       81
       81
       +
         {{ $currentState := "closed" }}

     

       82
       82
       +
         {{ if .FilteringByOpen }}

     

       83
       83
       +
           {{ $currentState = "open" }}

     

       84
       84
       +
         {{ end }}

     

       52
       85
        
       

     

       86
       86
       +
         {{ $prev := .Page.Previous.Offset }}

     

       87
       87
       +
         {{ $next := .Page.Next.Offset }}

     

       88
       88
       +
         {{ $lastPage := sub .IssueCount (mod .IssueCount .Page.Limit) }}

     

       89
       89
       +
       

     

       90
       90
       +
         <a

     

       91
       91
       +
           class="

     

       92
       92
       +
             btn flex items-center gap-2 no-underline hover:no-underline 

     

       93
       93
       +
             dark:text-white dark:hover:bg-gray-700

     

       94
       94
       +
             {{ if le .Page.Offset 0 }}

     

       95
       95
       +
               cursor-not-allowed opacity-50

     

       96
       96
       +
             {{ end }}

     

       97
       97
       +
           "

     

       53
       98
        
           {{ if gt .Page.Offset 0 }}

     

       54
       54
       -
              {{ $prev := .Page.Previous }}

     

       55
       55
       -
               <a

     

       56
       56
       -
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       57
       57
       -
                   hx-boost="true"

     

       58
       58
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"

     

       59
       59
       -
               >

     

       60
       60
       -
                   {{ i "chevron-left" "w-4 h-4" }}

     

       61
       61
       -
                   previous

     

       62
       62
       -
               </a>

     

       63
       63
       -
           {{ else }}

     

       64
       64
       -
               <div></div>

     

       99
       99
       +
             hx-boost="true"

     

       100
       100
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev }}&limit={{ .Page.Limit }}"

     

       65
       101
        
           {{ end }}

     

       102
       102
       +
         >

     

       103
       103
       +
           {{ i "chevron-left" "w-4 h-4" }}

     

       104
       104
       +
           previous

     

       105
       105
       +
         </a>

     

       106
       106
       +
       

     

       107
       107
       +
         <!-- dont show first page if current page is first page -->

     

       108
       108
       +
         {{ if gt .Page.Offset 0 }}

     

       109
       109
       +
           <a

     

       110
       110
       +
             hx-boost="true"

     

       111
       111
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset=0&limit={{ .Page.Limit }}"

     

       112
       112
       +
           >

     

       113
       113
       +
             1

     

       114
       114
       +
           </a>

     

       115
       115
       +
         {{ end }}

     

       116
       116
       +
       

     

       117
       117
       +
         <!-- if previous page is not first or second page (prev > limit) -->

     

       118
       118
       +
         {{ if gt $prev .Page.Limit }}

     

       119
       119
       +
           <span>...</span>

     

       120
       120
       +
         {{ end }}

     

       121
       121
       +
       

     

       122
       122
       +
         <!-- if previous page is not the first page -->

     

       123
       123
       +
         {{ if gt $prev 0 }}

     

       124
       124
       +
           <a

     

       125
       125
       +
             hx-boost="true"

     

       126
       126
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $prev }}&limit={{ .Page.Limit }}"

     

       127
       127
       +
           >

     

       128
       128
       +
             {{ add (div $prev .Page.Limit) 1 }}

     

       129
       129
       +
           </a>

     

       130
       130
       +
         {{ end }}

     

       131
       131
       +
       

     

       132
       132
       +
         <!-- current page. this is always visible -->

     

       133
       133
       +
         <span class="font-bold">

     

       134
       134
       +
           {{ add (div .Page.Offset .Page.Limit) 1 }}

     

       135
       135
       +
         </span>

     

       66
       136
        
       

     

       137
       137
       +
         <!-- if next page is not last page -->

     

       138
       138
       +
         {{ if lt $next $lastPage }}

     

       139
       139
       +
           <a

     

       140
       140
       +
             hx-boost="true"

     

       141
       141
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next }}&limit={{ .Page.Limit }}"

     

       142
       142
       +
           >

     

       143
       143
       +
             {{ add (div $next .Page.Limit) 1 }}

     

       144
       144
       +
           </a>

     

       145
       145
       +
         {{ end }}

     

       146
       146
       +
       

     

       147
       147
       +
         <!-- if next page is not second last or last page (next < issues - 2 * limit) -->

     

       148
       148
       +
         {{ if lt ($next) (sub .IssueCount (mul (2) .Page.Limit)) }}

     

       149
       149
       +
           <span>...</span>

     

       150
       150
       +
         {{ end }}

     

       151
       151
       +
       

     

       152
       152
       +
         <!-- if its not the last page -->

     

       153
       153
       +
         {{ if lt .Page.Offset $lastPage }} 

     

       154
       154
       +
           <a

     

       155
       155
       +
             hx-boost="true"

     

       156
       156
       +
             href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $lastPage }}&limit={{ .Page.Limit }}"

     

       157
       157
       +
           >

     

       158
       158
       +
             {{ add (div $lastPage .Page.Limit) 1 }}

     

       159
       159
       +
           </a>

     

       160
       160
       +
         {{ end }}

     

       161
       161
       +
       

     

       162
       162
       +
         <a

     

       163
       163
       +
           class="

     

       164
       164
       +
             btn flex items-center gap-2 no-underline hover:no-underline 

     

       165
       165
       +
             dark:text-white dark:hover:bg-gray-700

     

       166
       166
       +
             {{ if ne (len .Issues) .Page.Limit }}

     

       167
       167
       +
                 cursor-not-allowed opacity-50

     

       168
       168
       +
             {{ end }}

     

       169
       169
       +
           "

     

       67
       170
        
           {{ if eq (len .Issues) .Page.Limit }}

     

       68
       68
       -
              {{ $next := .Page.Next }}

     

       69
       69
       -
               <a

     

       70
       70
       -
                   class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       71
       71
       -
                   hx-boost="true"

     

       72
       72
       -
                   href = "/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&offset={{ $next.Offset }}&limit={{ $next.Limit }}"

     

       73
       73
       -
               >

     

       74
       74
       -
                   next

     

       75
       75
       -
                   {{ i "chevron-right" "w-4 h-4" }}

     

       76
       76
       -
               </a>

     

       171
       171
       +
             hx-boost="true"

     

       172
       172
       +
             href="/{{ $.RepoInfo.FullName }}/issues?state={{ $currentState }}&q={{ .FilterQuery }}&offset={{ $next }}&limit={{ .Page.Limit }}"

     

       77
       173
        
           {{ end }}

     

       174
       174
       +
         >

     

       175
       175
       +
           next

     

       176
       176
       +
           {{ i "chevron-right" "w-4 h-4" }}

     

       177
       177
       +
         </a>

     

       78
       178
        
       </div>

     

       79
       179
        
       {{ end }}

+40 -23

appview/pages/templates/repo/log.html

···

       17
       17
        
           <div class="hidden md:flex md:flex-col divide-y divide-gray-200 dark:divide-gray-700">

     

       18
       18
        
             {{ $grid := "grid grid-cols-14 gap-4" }}

     

       19
       19
        
             <div class="{{ $grid }}">

     

       20
       20
       -
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-2">Author</div>

     

       20
       20
       +
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Author</div>

     

       21
       21
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-3">Commit</div>

     

       22
       22
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-6">Message</div>

     

       23
       23
       -
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-1"></div>

     

       24
       23
        
               <div class="py-2 text-sm text-left text-gray-700 dark:text-gray-300 uppercase font-bold col-span-2 justify-self-end">Date</div>

     

       25
       24
        
             </div>

     

       26
       25
        
             {{ range $index, $commit := .Commits }}

     

       27
       26
        
               {{ $messageParts := splitN $commit.Message "\n\n" 2 }}

     

       28
       27
        
               <div class="{{ $grid }} py-3">

     

       29
       29
       -
                 <div class="align-top truncate col-span-2">

     

       30
       30
       -
                     {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       31
       31
       -
                     {{ if $didOrHandle }}

     

       32
       32
       -
                         {{ template "user/fragments/picHandleLink" $didOrHandle }}

     

       33
       33
       -
                     {{ else }}

     

       34
       34
       -
                         <a href="mailto:{{ $commit.Author.Email }}" class="text-gray-700 dark:text-gray-300 no-underline hover:underline">{{ $commit.Author.Name }}</a>

     

       35
       35
       -
                     {{ end }}

     

       28
       28
       +
                 <div class="align-top col-span-3">

     

       29
       29
       +
                   {{ template "attribution" (list $commit $.EmailToDid) }}

     

       36
       30
        
                 </div>

     

       37
       31
        
                 <div class="align-top font-mono flex items-start col-span-3">

     

       38
       32
        
                     {{ $verified := $.VerifiedCommits.IsVerified $commit.Hash.String }}

     
···

       61
       55
        
                 <div class="align-top col-span-6">

     

       62
       56
        
                   <div>

     

       63
       57
        
                       <a href="/{{ $.RepoInfo.FullName }}/commit/{{ $commit.Hash.String }}" class="dark:text-white no-underline hover:underline">{{ index $messageParts 0 }}</a>

     

       58
       58
       +
       

     

       64
       59
        
                       {{ if gt (len $messageParts) 1 }}

     

       65
       60
        
                       <button class="py-1/2 px-1 bg-gray-200 hover:bg-gray-400 dark:bg-gray-700 dark:hover:bg-gray-600 rounded" hx-on:click="this.parentElement.nextElementSibling.classList.toggle('hidden')">{{ i "ellipsis" "w-3 h-3" }}</button>

     

       66
       61
        
                       {{ end }}

     
···

       72
       67
        
                           </span>

     

       73
       68
        
                         {{ end }}

     

       74
       69
        
                       {{ end }}

     

       70
       70
       +
       

     

       71
       71
       +
                       <!-- ci status -->

     

       72
       72
       +
                       <span class="text-xs">

     

       73
       73
       +
                         {{ $pipeline := index $.Pipelines .Hash.String }}

     

       74
       74
       +
                         {{ if and $pipeline (gt (len $pipeline.Statuses) 0) }}

     

       75
       75
       +
                           {{ template "repo/pipelines/fragments/pipelineSymbolLong" (dict "Pipeline" $pipeline "RepoInfo" $.RepoInfo) }}

     

       76
       76
       +
                         {{ end }}

     

       77
       77
       +
                       </span>

     

       75
       78
        
                   </div>

     

       76
       79
        
       

     

       77
       80
        
                   {{ if gt (len $messageParts) 1 }}

     

       78
       81
        
                     <p class="hidden mt-1 text-sm text-gray-600 dark:text-gray-400">{{ nl2br (index $messageParts 1) }}</p>

     

       79
       82
        
                   {{ end }}

     

       80
       80
       -
                 </div>

     

       81
       81
       -
                 <div class="align-top col-span-1">

     

       82
       82
       -
                     <!-- ci status -->

     

       83
       83
       -
                     {{ $pipeline := index $.Pipelines .Hash.String }}

     

       84
       84
       -
                     {{ if and $pipeline (gt (len $pipeline.Statuses) 0) }}

     

       85
       85
       -
                       {{ template "repo/pipelines/fragments/pipelineSymbolLong" (dict "Pipeline" $pipeline "RepoInfo" $.RepoInfo) }}

     

       86
       86
       -
                     {{ end }}

     

       87
       83
        
                 </div>

     

       88
       84
        
                 <div class="align-top justify-self-end text-gray-500 dark:text-gray-400 col-span-2">{{ template "repo/fragments/shortTimeAgo" $commit.Committer.When }}</div>

     

       89
       85
        
               </div>

     
···

       152
       148
        
                               </a>

     

       153
       149
        
                           </span>

     

       154
       150
        
                           <span class="mx-2 before:content-['·'] before:select-none"></span>

     

       155
       155
       -
                           <span>

     

       156
       156
       -
                               {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       157
       157
       -
                               <a href="{{ if $didOrHandle }}/{{ $didOrHandle }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       158
       158
       -
                                  class="text-gray-500 dark:text-gray-400 no-underline hover:underline">

     

       159
       159
       -
                                  {{ if $didOrHandle }}{{ template "user/fragments/picHandleLink" $didOrHandle }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       160
       160
       -
                               </a>

     

       161
       161
       -
                           </span>

     

       151
       151
       +
                           {{ template "attribution" (list $commit $.EmailToDid) }}

     

       162
       152
        
                           <div class="inline-block px-1 select-none after:content-['·']"></div>

     

       163
       153
        
                           <span>{{ template "repo/fragments/shortTime" $commit.Committer.When }}</span>

     

       164
       154
        
       

     
···

       176
       166
        
           </div>

     

       177
       167
        
       </section>

     

       178
       168
        
       

     

       169
       169
       +
       {{ end }}

     

       170
       170
       +
       

     

       171
       171
       +
       {{ define "attribution" }}

     

       172
       172
       +
         {{ $commit := index . 0 }}

     

       173
       173
       +
         {{ $map := index . 1 }}

     

       174
       174
       +
         <span class="flex items-center gap-1">

     

       175
       175
       +
           {{ $author := index $map $commit.Author.Email }}

     

       176
       176
       +
           {{ $coauthors := $commit.CoAuthors }}

     

       177
       177
       +
           {{ $all := list }}

     

       178
       178
       +
       

     

       179
       179
       +
           {{ if $author }}

     

       180
       180
       +
               {{ $all = append $all $author }}

     

       181
       181
       +
           {{ end }}

     

       182
       182
       +
           {{ range $coauthors }}

     

       183
       183
       +
             {{ $co := index $map .Email }}

     

       184
       184
       +
             {{ if $co }}

     

       185
       185
       +
               {{ $all = append $all $co }}

     

       186
       186
       +
             {{ end }}

     

       187
       187
       +
           {{ end }}

     

       188
       188
       +
       

     

       189
       189
       +
           {{ template "fragments/tinyAvatarList" (dict "all" $all "classes" "size-6") }}

     

       190
       190
       +
           <a href="{{ if $author }}/{{ $author }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}"

     

       191
       191
       +
              class="no-underline hover:underline">

     

       192
       192
       +
              {{ if $author }}{{ resolve $author }}{{ else }}{{ $commit.Author.Name }}{{ end }}

     

       193
       193
       +
              {{ if $coauthors }} +{{ length $coauthors }}{{ end }}

     

       194
       194
       +
           </a>

     

       195
       195
       +
         </span>

     

       179
       196
        
       {{ end }}

     

       180
       197
        
       

     

       181
       198
        
       {{ define "repoAfter" }}

+2 -1

appview/pages/templates/repo/new.html

···

       155
       155
        
                   class="mr-2"

     

       156
       156
        
                   id="domain-{{ . }}"

     

       157
       157
        
                   required

     

       158
       158
       +
                   {{if eq (len $.Knots) 1}}checked{{end}}

     

       158
       159
        
                 />

     

       159
       160
        
                 <label for="domain-{{ . }}" class="dark:text-white lowercase">{{ . }}</label>

     

       160
       161
        
               </div>

     
···

       164
       165
        
           </div>

     

       165
       166
        
           <p class="text-sm text-gray-500 dark:text-gray-400 mt-1">

     

       166
       167
        
             A knot hosts repository data and handles Git operations.

     

       167
       167
       -
             You can also <a href="/knots" class="underline">register your own knot</a>.

     

       168
       168
       +
             You can also <a href="/settings/knots" class="underline">register your own knot</a>.

     

       168
       169
        
           </p>

     

       169
       170
        
         </div>

     

       170
       171
        
       {{ end }}

+7 -6

appview/pages/templates/repo/pipelines/fragments/logBlock.html

···

       2
       2
        
       <div id="lines" hx-swap-oob="beforeend">

     

       3
       3
        
         <details id="step-{{ .Id }}" {{if not .Collapsed}}open{{end}} class="group pb-2 rounded-sm border border-gray-200 dark:border-gray-700">

     

       4
       4
        
           <summary class="sticky top-0 pt-2 px-2 group-open:pb-2 group-open:mb-2 list-none cursor-pointer group-open:border-b border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:text-gray-500 hover:dark:text-gray-400">

     

       5
       5
       -
             <div class="group-open:hidden flex items-center gap-1">

     

       6
       6
       -
               {{ i "chevron-right" "w-4 h-4" }} {{ .Name }}

     

       7
       7
       -
             </div>

     

       8
       8
       -
             <div class="hidden group-open:flex items-center gap-1">

     

       9
       9
       -
               {{ i "chevron-down" "w-4 h-4" }} {{ .Name }}

     

       10
       10
       -
             </div>

     

       5
       5
       +
             <div class="group-open:hidden flex items-center gap-1">{{ i "chevron-right" "w-4 h-4" }} {{ template "stepHeader" . }}</div>

     

       6
       6
       +
             <div class="hidden group-open:flex items-center gap-1">{{ i "chevron-down" "w-4 h-4" }} {{ template "stepHeader" . }}</div>

     

       11
       7
        
           </summary>

     

       12
       8
        
           <div class="font-mono whitespace-pre overflow-x-auto px-2"><div class="text-blue-600 dark:text-blue-300">{{ .Command }}</div><div id="step-body-{{ .Id }}"></div></div>

     

       13
       9
        
         </details>

     

       14
       10
        
       </div>

     

       15
       11
        
       {{ end }}

     

       12
       12
       +
       

     

       13
       13
       +
       {{ define "stepHeader" }}

     

       14
       14
       +
        {{ .Name }}

     

       15
       15
       +
        <span class="ml-auto text-sm text-gray-500 tabular-nums" data-timer="{{ .Id }}" data-start="{{ .StartTime.Unix }}"></span>

     

       16
       16
       +
       {{ end }}

appview/pages/templates/repo/pipelines/fragments/logBlockEnd.html

···

       1
       1
       +
       {{ define "repo/pipelines/fragments/logBlockEnd" }}

     

       2
       2
       +
         <span

     

       3
       3
       +
           class="ml-auto text-sm text-gray-500 tabular-nums"

     

       4
       4
       +
           data-timer="{{ .Id }}"

     

       5
       5
       +
           data-start="{{ .StartTime.Unix }}"

     

       6
       6
       +
           data-end="{{ .EndTime.Unix }}"

     

       7
       7
       +
           hx-swap-oob="outerHTML:[data-timer='{{ .Id }}']"></span>

     

       8
       8
       +
       {{ end }}

     

       9
       9
       +

+15 -3

appview/pages/templates/repo/pipelines/pipelines.html

···

       12
       12
        
         {{ range .Pipelines }}

     

       13
       13
        
           {{ block "pipeline" (list $ .) }} {{ end }}

     

       14
       14
        
         {{ else }}

     

       15
       15
       -
           <p class="text-center pt-5 text-gray-400 dark:text-gray-500">

     

       16
       16
       -
             No pipelines run for this repository.

     

       17
       17
       -
           </p>

     

       15
       15
       +
           <div class="py-6 w-fit flex flex-col gap-4 mx-auto">

     

       16
       16
       +
             <p>

     

       17
       17
       +
               No pipelines have been run for this repository yet. To get started:

     

       18
       18
       +
             </p>

     

       19
       19
       +
             {{ $bullet := "mx-2 text-xs bg-gray-200 dark:bg-gray-600 rounded-full size-5 flex items-center justify-center font-mono inline-flex align-middle" }}

     

       20
       20
       +
             <p>

     

       21
       21
       +
               <span class="{{ $bullet }}">1</span>First, choose a spindle in your

     

       22
       22
       +
               <a href="/{{ .RepoInfo.FullName }}/settings?tab=pipelines" class="underline">repository settings</a>.

     

       23
       23
       +
             </p>

     

       24
       24
       +
             <p>

     

       25
       25
       +
               <span class="{{ $bullet }}">2</span>Configure your CI/CD

     

       26
       26
       +
               <a href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/pipeline.md" class="underline">pipeline</a>.

     

       27
       27
       +
             </p>

     

       28
       28
       +
             <p><span class="{{ $bullet }}">3</span>Trigger a workflow with a push or a pull-request!</p>

     

       29
       29
       +
           </div>

     

       18
       30
        
         {{ end }}

     

       19
       31
        
         </div>

     

       20
       32
        
       </div>

appview/pages/templates/repo/pipelines/workflow.html

···

       15
       15
        
           {{ block "logs" . }} {{ end }}

     

       16
       16
        
         </div>

     

       17
       17
        
       </section>

     

       18
       18
       +
       {{ template "fragments/workflow-timers" }}

     

       18
       19
        
       {{ end }}

     

       19
       20
        
       

     

       20
       21
        
       {{ define "sidebar" }}

     
···

       58
       59
        
              hx-ext="ws"

     

       59
       60
        
              ws-connect="/{{ $.RepoInfo.FullName }}/pipelines/{{ .Pipeline.Id }}/workflow/{{ .Workflow }}/logs">

     

       60
       61
        
           <div id="lines" class="flex flex-col gap-2">

     

       62
       62
       +
             <div class="text-base text-gray-500 flex items-center justify-center italic p-12 only:flex hidden border border-gray-200 dark:border-gray-700 rounded">

     

       63
       63
       +
               <span class="flex items-center gap-2">

     

       64
       64
       +
                 {{ i "triangle-alert" "size-4" }} No logs for this workflow

     

       65
       65
       +
               </span>

     

       66
       66
       +
             </div>

     

       61
       67
        
           </div>

     

       62
       68
        
         </div>

     

       63
       69
        
       {{ end }}

+81 -83

appview/pages/templates/repo/pulls/fragments/pullActions.html

···

       22
       22
        
         {{ $isLastRound := eq $roundNumber $lastIdx }}

     

       23
       23
        
         {{ $isSameRepoBranch := .Pull.IsBranchBased }}

     

       24
       24
        
         {{ $isUpToDate := .ResubmitCheck.No }}

     

       25
       25
       -
         <div class="relative w-fit">

     

       26
       26
       -
           <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2">

     

       27
       27
       -
               <button 

     

       28
       28
       -
                 hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       29
       29
       -
                 hx-target="#actions-{{$roundNumber}}"

     

       30
       30
       -
                 hx-swap="outerHtml"

     

       31
       31
       -
                 class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       32
       32
       -
                   {{ i "message-square-plus" "w-4 h-4" }}

     

       33
       33
       -
                   <span>comment</span>

     

       34
       34
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       35
       35
       -
               </button>

     

       36
       36
       -
               {{ if .BranchDeleteStatus }}

     

       37
       37
       -
                 <button 

     

       38
       38
       -
                   hx-delete="/{{ .BranchDeleteStatus.Repo.Did }}/{{ .BranchDeleteStatus.Repo.Name }}/branches"

     

       39
       39
       -
                   hx-vals='{"branch": "{{ .BranchDeleteStatus.Branch }}" }'

     

       40
       40
       -
                   hx-swap="none"

     

       41
       41
       -
                   class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300">

     

       42
       42
       -
                     {{ i "git-branch" "w-4 h-4" }}

     

       43
       43
       -
                     <span>delete branch</span>

     

       44
       44
       -
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       45
       45
       -
                 </button>

     

       46
       46
       -
               {{ end }}

     

       47
       47
       -
               {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       48
       48
       -
                 {{ $disabled := "" }}

     

       49
       49
       -
                 {{ if $isConflicted }}

     

       50
       50
       -
                   {{ $disabled = "disabled" }}

     

       51
       51
       -
                 {{ end }}

     

       52
       52
       -
                 <button 

     

       53
       53
       -
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       54
       54
       -
                   hx-swap="none"

     

       55
       55
       -
                   hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       56
       56
       -
                   class="btn p-2 flex items-center gap-2 group" {{ $disabled }}>

     

       57
       57
       -
                   {{ i "git-merge" "w-4 h-4" }}

     

       58
       58
       -
                   <span>merge{{if $stackCount}} {{$stackCount}}{{end}}</span>

     

       59
       59
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       60
       60
       -
                 </button>

     

       61
       61
       -
               {{ end }}

     

       25
       25
       +
         <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2 relative">

     

       26
       26
       +
           <button 

     

       27
       27
       +
             hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       28
       28
       +
             hx-target="#actions-{{$roundNumber}}"

     

       29
       29
       +
             hx-swap="outerHtml"

     

       30
       30
       +
             class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       31
       31
       +
               {{ i "message-square-plus" "w-4 h-4" }}

     

       32
       32
       +
               <span>comment</span>

     

       33
       33
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       34
       34
       +
           </button>

     

       35
       35
       +
           {{ if .BranchDeleteStatus }}

     

       36
       36
       +
             <button 

     

       37
       37
       +
               hx-delete="/{{ .BranchDeleteStatus.Repo.Did }}/{{ .BranchDeleteStatus.Repo.Name }}/branches"

     

       38
       38
       +
               hx-vals='{"branch": "{{ .BranchDeleteStatus.Branch }}" }'

     

       39
       39
       +
               hx-swap="none"

     

       40
       40
       +
               class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300">

     

       41
       41
       +
                 {{ i "git-branch" "w-4 h-4" }}

     

       42
       42
       +
                 <span>delete branch</span>

     

       43
       43
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       44
       44
       +
             </button>

     

       45
       45
       +
           {{ end }}

     

       46
       46
       +
           {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       47
       47
       +
             {{ $disabled := "" }}

     

       48
       48
       +
             {{ if $isConflicted }}

     

       49
       49
       +
               {{ $disabled = "disabled" }}

     

       50
       50
       +
             {{ end }}

     

       51
       51
       +
             <button 

     

       52
       52
       +
               hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       53
       53
       +
               hx-swap="none"

     

       54
       54
       +
               hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       55
       55
       +
               class="btn p-2 flex items-center gap-2 group" {{ $disabled }}>

     

       56
       56
       +
               {{ i "git-merge" "w-4 h-4" }}

     

       57
       57
       +
               <span>merge{{if $stackCount}} {{$stackCount}}{{end}}</span>

     

       58
       58
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       59
       59
       +
             </button>

     

       60
       60
       +
           {{ end }}

     

       62
       61
        
       

     

       63
       63
       -
               {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       64
       64
       -
                 {{ $disabled := "" }}

     

       65
       65
       -
                 {{ if $isUpToDate }}

     

       66
       66
       -
                   {{ $disabled = "disabled" }}

     

       62
       62
       +
           {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       63
       63
       +
             {{ $disabled := "" }}

     

       64
       64
       +
             {{ if $isUpToDate }}

     

       65
       65
       +
               {{ $disabled = "disabled" }}

     

       66
       66
       +
             {{ end }}

     

       67
       67
       +
             <button id="resubmitBtn"

     

       68
       68
       +
                 {{ if not .Pull.IsPatchBased }}

     

       69
       69
       +
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       70
       70
       +
                 {{ else }}

     

       71
       71
       +
                   hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       72
       72
       +
                   hx-target="#actions-{{$roundNumber}}"

     

       73
       73
       +
                   hx-swap="outerHtml"

     

       67
       74
        
                 {{ end }}

     

       68
       68
       -
                 <button id="resubmitBtn"

     

       69
       69
       -
                     {{ if not .Pull.IsPatchBased }}

     

       70
       70
       -
                       hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       71
       71
       -
                     {{ else }}

     

       72
       72
       -
                       hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       73
       73
       -
                       hx-target="#actions-{{$roundNumber}}"

     

       74
       74
       -
                       hx-swap="outerHtml"

     

       75
       75
       -
                     {{ end }}

     

       76
       75
        
       

     

       77
       77
       -
                     hx-disabled-elt="#resubmitBtn"

     

       78
       78
       -
                     class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group" {{ $disabled }}

     

       76
       76
       +
                 hx-disabled-elt="#resubmitBtn"

     

       77
       77
       +
                 class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group" {{ $disabled }}

     

       79
       78
        
       

     

       80
       80
       -
                     {{ if $disabled }}

     

       81
       81
       -
                     title="Update this branch to resubmit this pull request"

     

       82
       82
       -
                     {{ else }}

     

       83
       83
       -
                     title="Resubmit this pull request"

     

       84
       84
       -
                     {{ end }}

     

       85
       85
       -
                     >

     

       86
       86
       -
                     {{ i "rotate-ccw" "w-4 h-4" }}

     

       87
       87
       -
                     <span>resubmit</span>

     

       88
       88
       -
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       89
       89
       -
                 </button>

     

       90
       90
       -
               {{ end }}

     

       79
       79
       +
                 {{ if $disabled }}

     

       80
       80
       +
                 title="Update this branch to resubmit this pull request"

     

       81
       81
       +
                 {{ else }}

     

       82
       82
       +
                 title="Resubmit this pull request"

     

       83
       83
       +
                 {{ end }}

     

       84
       84
       +
                 >

     

       85
       85
       +
                 {{ i "rotate-ccw" "w-4 h-4" }}

     

       86
       86
       +
                 <span>resubmit</span>

     

       87
       87
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       88
       88
       +
             </button>

     

       89
       89
       +
           {{ end }}

     

       91
       90
        
       

     

       92
       92
       -
               {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       93
       93
       -
               <button 

     

       94
       94
       -
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       95
       95
       -
                 hx-swap="none"

     

       96
       96
       -
                 class="btn p-2 flex items-center gap-2 group">

     

       97
       97
       -
                   {{ i "ban" "w-4 h-4" }}

     

       98
       98
       -
                   <span>close</span>

     

       99
       99
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       100
       100
       -
               </button>

     

       101
       101
       -
               {{ end }}

     

       91
       91
       +
           {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       92
       92
       +
           <button 

     

       93
       93
       +
             hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       94
       94
       +
             hx-swap="none"

     

       95
       95
       +
             class="btn p-2 flex items-center gap-2 group">

     

       96
       96
       +
               {{ i "ban" "w-4 h-4" }}

     

       97
       97
       +
               <span>close</span>

     

       98
       98
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       99
       99
       +
           </button>

     

       100
       100
       +
           {{ end }}

     

       102
       101
        
       

     

       103
       103
       -
               {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       104
       104
       -
               <button 

     

       105
       105
       -
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       106
       106
       -
                 hx-swap="none"

     

       107
       107
       -
                 class="btn p-2 flex items-center gap-2 group">

     

       108
       108
       -
                   {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       109
       109
       -
                   <span>reopen</span>

     

       110
       110
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       111
       111
       -
               </button>

     

       112
       112
       -
               {{ end }}

     

       113
       113
       -
           </div>

     

       102
       102
       +
           {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       103
       103
       +
           <button 

     

       104
       104
       +
             hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       105
       105
       +
             hx-swap="none"

     

       106
       106
       +
             class="btn p-2 flex items-center gap-2 group">

     

       107
       107
       +
               {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       108
       108
       +
               <span>reopen</span>

     

       109
       109
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       110
       110
       +
           </button>

     

       111
       111
       +
           {{ end }}

     

       114
       112
        
         </div>

     

       115
       113
        
       {{ end }}

     

       116
       114

+1 -1

appview/pages/templates/repo/pulls/fragments/pullHeader.html

···

       75
       75
        
                           "Kind"      $kind

     

       76
       76
        
                           "Count"     $reactionData.Count

     

       77
       77
        
                           "IsReacted" (index $.UserReacted $kind)

     

       78
       78
       -
                           "ThreadAt"  $.Pull.PullAt

     

       78
       78
       +
                           "ThreadAt"  $.Pull.AtUri

     

       79
       79
        
                           "Users"     $reactionData.Users)

     

       80
       80
        
                   }}

     

       81
       81
        
               {{ end }}

+1 -1

appview/pages/templates/repo/pulls/patch.html

···

       54
       54
        
       {{ end }}

     

       55
       55
        
       

     

       56
       56
        
       {{ define "contentAfter" }}

     

       57
       57
       -
         {{ template "repo/fragments/diff" (list .RepoInfo.FullName .Diff .DiffOpts) }}

     

       57
       57
       +
         {{ template "repo/fragments/diff" (list .Diff .DiffOpts) }}

     

       58
       58
        
       {{end}}

     

       59
       59
        
       

     

       60
       60
        
       {{ define "contentAfterLeft" }}

+5 -1

appview/pages/templates/repo/pulls/pull.html

···

       18
       18
        
             {{ template "repo/fragments/labelPanel"

     

       19
       19
        
               (dict "RepoInfo" $.RepoInfo

     

       20
       20
        
                     "Defs" $.LabelDefs

     

       21
       21
       -
                     "Subject" $.Pull.PullAt

     

       21
       21
       +
                     "Subject" $.Pull.AtUri

     

       22
       22
        
                     "State" $.Pull.Labels) }}

     

       23
       23
        
             {{ template "repo/fragments/participants" $.Pull.Participants }}

     

       24
       24
       +
             {{ template "repo/fragments/backlinks"

     

       25
       25
       +
               (dict "RepoInfo" $.RepoInfo

     

       26
       26
       +
                     "Backlinks" $.Backlinks) }}

     

       27
       27
       +
             {{ template "repo/fragments/externalLinkPanel" $.Pull.AtUri }}

     

       24
       28
        
           </div>

     

       25
       29
        
         </div>

     

       26
       30
        
       {{ end }}

+61 -31

appview/pages/templates/repo/pulls/pulls.html

···

       8
       8
        
       {{ end }}

     

       9
       9
        
       

     

       10
       10
        
       {{ define "repoContent" }}

     

       11
       11
       -
           <div class="flex justify-between items-center">

     

       12
       12
       -
               <div class="flex gap-4">

     

       13
       13
       -
                   <a

     

       14
       14
       -
                       href="?state=open"

     

       15
       15
       -
                       class="flex items-center gap-2 {{ if .FilteringBy.IsOpen }}font-bold {{ else }}text-gray-500 dark:text-gray-400{{ end }}"

     

       16
       16
       -
                   >

     

       17
       17
       -
                       {{ i "git-pull-request" "w-4 h-4" }}

     

       18
       18
       -
                       <span>{{ .RepoInfo.Stats.PullCount.Open }} open</span>

     

       19
       19
       -
                   </a>

     

       20
       20
       -
                   <a

     

       21
       21
       -
                       href="?state=merged"

     

       22
       22
       -
                       class="flex items-center gap-2 {{ if .FilteringBy.IsMerged }}font-bold {{ else }}text-gray-500 dark:text-gray-400{{ end }}"

     

       23
       23
       -
                   >

     

       24
       24
       -
                       {{ i "git-merge" "w-4 h-4" }}

     

       25
       25
       -
                       <span>{{ .RepoInfo.Stats.PullCount.Merged }} merged</span>

     

       26
       26
       -
                   </a>

     

       27
       27
       -
                   <a

     

       28
       28
       -
                       href="?state=closed"

     

       29
       29
       -
                       class="flex items-center gap-2 {{ if .FilteringBy.IsClosed }}font-bold {{ else }}text-gray-500 dark:text-gray-400{{ end }}"

     

       30
       30
       -
                   >

     

       31
       31
       -
                       {{ i "ban" "w-4 h-4" }}

     

       32
       32
       -
                       <span>{{ .RepoInfo.Stats.PullCount.Closed }} closed</span>

     

       33
       33
       -
                   </a>

     

       34
       34
       -
               </div>

     

       11
       11
       +
         {{ $active := "closed" }}

     

       12
       12
       +
         {{ if .FilteringBy.IsOpen  }}

     

       13
       13
       +
           {{ $active = "open" }}

     

       14
       14
       +
         {{ else if .FilteringBy.IsMerged  }}

     

       15
       15
       +
           {{ $active = "merged" }}

     

       16
       16
       +
         {{ end }}

     

       17
       17
       +
         {{ $open := 

     

       18
       18
       +
            (dict

     

       19
       19
       +
              "Key" "open"

     

       20
       20
       +
              "Value" "open"

     

       21
       21
       +
              "Icon" "git-pull-request"

     

       22
       22
       +
              "Meta" (string .RepoInfo.Stats.PullCount.Open)) }}

     

       23
       23
       +
         {{ $merged := 

     

       24
       24
       +
            (dict

     

       25
       25
       +
              "Key" "merged"

     

       26
       26
       +
              "Value" "merged"

     

       27
       27
       +
              "Icon" "git-merge"

     

       28
       28
       +
              "Meta" (string .RepoInfo.Stats.PullCount.Merged)) }}

     

       29
       29
       +
         {{ $closed := 

     

       30
       30
       +
            (dict

     

       31
       31
       +
              "Key" "closed"

     

       32
       32
       +
              "Value" "closed"

     

       33
       33
       +
              "Icon" "ban"

     

       34
       34
       +
              "Meta" (string .RepoInfo.Stats.PullCount.Closed)) }}

     

       35
       35
       +
         {{ $values := list $open $merged $closed }}

     

       36
       36
       +
         <div class="grid gap-2 grid-cols-[auto_1fr_auto] grid-row-2">

     

       37
       37
       +
           <form class="flex relative col-span-3 sm:col-span-1 sm:col-start-2" method="GET">

     

       38
       38
       +
             <input type="hidden" name="state" value="{{ .FilteringBy.String }}">

     

       39
       39
       +
             <div class="flex-1 flex relative">

     

       40
       40
       +
               <input

     

       41
       41
       +
                 id="search-q"

     

       42
       42
       +
                 class="flex-1 py-1 pl-2 pr-10 mr-[-1px] rounded-r-none focus:border-0 focus:outline-none focus:ring focus:ring-blue-400 ring-inset peer"

     

       43
       43
       +
                 type="text"

     

       44
       44
       +
                 name="q"

     

       45
       45
       +
                 value="{{ .FilterQuery }}"

     

       46
       46
       +
                 placeholder=" "

     

       47
       47
       +
               >

     

       35
       48
        
               <a

     

       36
       36
       -
                   href="/{{ .RepoInfo.FullName }}/pulls/new"

     

       37
       37
       -
                   class="btn-create text-sm flex items-center gap-2 no-underline hover:no-underline hover:text-white"

     

       49
       49
       +
                 href="?state={{ .FilteringBy.String }}"

     

       50
       50
       +
                 class="absolute right-3 top-1/2 -translate-y-1/2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 hidden peer-[:not(:placeholder-shown)]:block"

     

       38
       51
        
               >

     

       39
       39
       -
                   {{ i "git-pull-request-create" "w-4 h-4" }}

     

       40
       40
       -
                   <span>new</span>

     

       52
       52
       +
                 {{ i "x" "w-4 h-4" }}

     

       41
       53
        
               </a>

     

       54
       54
       +
             </div>

     

       55
       55
       +
             <button

     

       56
       56
       +
               type="submit"

     

       57
       57
       +
               class="p-2 text-gray-400 border rounded-r border-gray-400 dark:border-gray-600"

     

       58
       58
       +
             >

     

       59
       59
       +
               {{ i "search" "w-4 h-4" }}

     

       60
       60
       +
             </button>

     

       61
       61
       +
           </form>

     

       62
       62
       +
           <div class="sm:row-start-1">

     

       63
       63
       +
             {{ template "fragments/tabSelector" (dict "Name" "state" "Values" $values "Active" $active "Include" "#search-q") }}

     

       42
       64
        
           </div>

     

       43
       43
       -
           <div class="error" id="pulls"></div>

     

       65
       65
       +
           <a

     

       66
       66
       +
             href="/{{ .RepoInfo.FullName }}/pulls/new"

     

       67
       67
       +
             class="col-start-3 btn-create text-sm flex items-center gap-2 no-underline hover:no-underline hover:text-white"

     

       68
       68
       +
           >

     

       69
       69
       +
             {{ i "git-pull-request-create" "w-4 h-4" }}

     

       70
       70
       +
             <span>new</span>

     

       71
       71
       +
           </a>

     

       72
       72
       +
         </div>

     

       73
       73
       +
         <div class="error" id="pulls"></div>

     

       44
       74
        
       {{ end }}

     

       45
       75
        
       

     

       46
       76
        
       {{ define "repoAfter" }}

     
···

       133
       163
        
                               {{ i "chevrons-down-up" "w-4 h-4" }} hide {{ len $otherPulls }} pull{{$s}} in this stack

     

       134
       164
        
                             </div>

     

       135
       165
        
                           </summary>

     

       136
       136
       -
                           {{ block "pullList" (list $otherPulls $) }} {{ end }}

     

       166
       166
       +
                           {{ block "stackedPullList" (list $otherPulls $) }} {{ end }}

     

       137
       167
        
                         </details>

     

       138
       168
        
                       {{ end }}

     

       139
       169
        
                     {{ end }}

     
···

       142
       172
        
           </div>

     

       143
       173
        
       {{ end }}

     

       144
       174
        
       

     

       145
       145
       -
       {{ define "pullList" }}

     

       175
       175
       +
       {{ define "stackedPullList" }}

     

       146
       176
        
         {{ $list := index . 0 }}

     

       147
       177
        
         {{ $root := index . 1 }}

     

       148
       178
        
         <div class="grid grid-cols-1 rounded-b border-b border-t border-gray-200 dark:border-gray-900 divide-y divide-gray-200 dark:divide-gray-900">

+22 -12

appview/pages/templates/repo/settings/access.html

···

       29
       29
        
             {{ template "addCollaboratorButton" . }}

     

       30
       30
        
           {{ end }}

     

       31
       31
        
           {{ range .Collaborators }}

     

       32
       32
       +
             {{ $handle := resolve .Did }}

     

       32
       33
        
             <div class="border border-gray-200 dark:border-gray-700 rounded p-4">

     

       33
       34
        
               <div class="flex items-center gap-3">

     

       34
       35
        
                 <img

     

       35
       35
       -
                   src="{{ fullAvatar .Handle }}"

     

       36
       36
       -
                   alt="{{ .Handle }}"

     

       36
       36
       +
                   src="{{ fullAvatar $handle }}"

     

       37
       37
       +
                   alt="{{ $handle }}"

     

       37
       38
        
                   class="rounded-full h-10 w-10 border border-gray-300 dark:border-gray-600 flex-shrink-0"/>

     

       38
       39
        
       

     

       39
       40
        
                 <div class="flex-1 min-w-0">

     

       40
       40
       -
                   <a href="/{{ .Handle }}" class="block truncate">

     

       41
       41
       -
                     {{ didOrHandle .Did .Handle }}

     

       41
       41
       +
                   <a href="/{{ $handle }}" class="block truncate">

     

       42
       42
       +
                     {{ $handle }}

     

       42
       43
        
                   </a>

     

       43
       44
        
                   <p class="text-sm text-gray-500 dark:text-gray-400">{{ .Role }}</p>

     

       44
       45
        
                 </div>

     
···

       66
       67
        
         <div

     

       67
       68
        
           id="add-collaborator-modal"

     

       68
       69
        
           popover

     

       69
       69
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       70
       70
       +
           class="

     

       71
       71
       +
             bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 

     

       72
       72
       +
             dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50 

     

       73
       73
       +
             w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       70
       74
        
           {{ template "addCollaboratorModal" . }}

     

       71
       75
        
         </div>

     

       72
       76
        
       {{ end }}

     
···

       82
       86
        
           ADD COLLABORATOR

     

       83
       87
        
         </label>

     

       84
       88
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Collaborators can push to this repository.</p>

     

       85
       85
       -
         <input

     

       86
       86
       -
           type="text"

     

       87
       87
       -
           id="add-collaborator"

     

       88
       88
       -
           name="collaborator"

     

       89
       89
       -
           required

     

       90
       90
       -
           placeholder="@foo.bsky.social"

     

       91
       91
       -
         />

     

       89
       89
       +
         <actor-typeahead>

     

       90
       90
       +
           <input

     

       91
       91
       +
             autocapitalize="none"

     

       92
       92
       +
             autocorrect="off"

     

       93
       93
       +
             autocomplete="off"

     

       94
       94
       +
             type="text"

     

       95
       95
       +
             id="add-collaborator"

     

       96
       96
       +
             name="collaborator"

     

       97
       97
       +
             required

     

       98
       98
       +
             placeholder="user.tngl.sh"

     

       99
       99
       +
             class="w-full"

     

       100
       100
       +
           />

     

       101
       101
       +
         </actor-typeahead>

     

       92
       102
        
         <div class="flex gap-2 pt-2">

     

       93
       103
        
           <button

     

       94
       104
        
             type="button"

+47

appview/pages/templates/repo/settings/general.html

···

       6
       6
        
             {{ template "repo/settings/fragments/sidebar" . }}

     

       7
       7
        
           </div>

     

       8
       8
        
           <div class="col-span-1 md:col-span-3 flex flex-col gap-6 p-2">

     

       9
       9
       +
             {{ template "baseSettings" . }}

     

       9
       10
        
             {{ template "branchSettings" . }}

     

       10
       11
        
             {{ template "defaultLabelSettings" . }}

     

       11
       12
        
             {{ template "customLabelSettings" . }}

     
···

       13
       14
        
             <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       14
       15
        
           </div>

     

       15
       16
        
         </section>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "baseSettings" }}

     

       20
       20
       +
         <form hx-put="/{{ $.RepoInfo.FullName }}/settings/base" hx-swap="none">

     

       21
       21
       +
           <fieldset

     

       22
       22
       +
             class=""

     

       23
       23
       +
             {{ if not .RepoInfo.Roles.IsOwner }}disabled{{ end }}

     

       24
       24
       +
           >

     

       25
       25
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Description</h2>

     

       26
       26
       +
             <textarea

     

       27
       27
       +
               rows="3"

     

       28
       28
       +
               class="w-full mb-2"

     

       29
       29
       +
               id="base-form-description"

     

       30
       30
       +
               name="description"

     

       31
       31
       +
               >{{ .RepoInfo.Description }}</textarea>

     

       32
       32
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Website URL</h2>

     

       33
       33
       +
             <input

     

       34
       34
       +
               type="text"

     

       35
       35
       +
               class="w-full mb-2"

     

       36
       36
       +
               id="base-form-website"

     

       37
       37
       +
               name="website"

     

       38
       38
       +
               value="{{ .RepoInfo.Website }}"

     

       39
       39
       +
             >

     

       40
       40
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Topics</h2>

     

       41
       41
       +
             <p class="text-gray-500 dark:text-gray-400">

     

       42
       42
       +
               List of topics separated by spaces.

     

       43
       43
       +
             </p>

     

       44
       44
       +
             <textarea

     

       45
       45
       +
               rows="2"

     

       46
       46
       +
               class="w-full my-2"

     

       47
       47
       +
               id="base-form-topics"

     

       48
       48
       +
               name="topics"

     

       49
       49
       +
             >{{ range $topic := .RepoInfo.Topics }}{{ $topic }} {{ end }}</textarea>

     

       50
       50
       +
             <div id="repo-base-settings-error" class="text-red-500 dark:text-red-400"></div>

     

       51
       51
       +
             <div class="flex justify-end pt-2">

     

       52
       52
       +
               <button

     

       53
       53
       +
                 type="submit"

     

       54
       54
       +
                 class="btn-create flex items-center gap-2 group"

     

       55
       55
       +
               >

     

       56
       56
       +
                 {{ i "save" "w-4 h-4" }}

     

       57
       57
       +
                 save

     

       58
       58
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       59
       59
       +
               </button>

     

       60
       60
       +
             </div>

     

       61
       61
       +
           </fieldset>

     

       62
       62
       +
         </form>

     

       16
       63
        
       {{ end }}

     

       17
       64
        
       

     

       18
       65
        
       {{ define "branchSettings" }}

appview/pages/templates/repo/tree.html

···

       59
       59
        
                 {{ $icon := "folder" }}

     

       60
       60
        
                 {{ $iconStyle := "size-4 fill-current" }}

     

       61
       61
        
       

     

       62
       62
       +
                 {{ if .IsSubmodule }}

     

       63
       63
       +
                   {{ $link = printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) $.TreePath .Name }}

     

       64
       64
       +
                   {{ $icon = "folder-input" }}

     

       65
       65
       +
                   {{ $iconStyle = "size-4" }}

     

       66
       66
       +
                 {{ end }}

     

       67
       67
       +
       

     

       62
       68
        
                 {{ if .IsFile }}

     

       69
       69
       +
                   {{ $link = printf "/%s/%s/%s/%s/%s" $.RepoInfo.FullName "blob" (urlquery $.Ref) $.TreePath .Name }}

     

       63
       70
        
                   {{ $icon = "file" }}

     

       64
       71
        
                   {{ $iconStyle = "size-4" }}

     

       65
       72
        
                 {{ end }}

     

       73
       73
       +
       

     

       66
       74
        
                 <a href="{{ $link }}" class="{{ $linkstyle }}">

     

       67
       75
        
                   <div class="flex items-center gap-2">

     

       68
       76
        
                     {{ i $icon $iconStyle "flex-shrink-0" }}

+22 -6

appview/pages/templates/spindles/dashboard.html

···

       1
       1
       -
       {{ define "title" }}{{.Spindle.Instance}} &middot; spindles{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{.Spindle.Instance}} &middot; {{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4">

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "spindleDash" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "spindleDash" }}

     

       20
       20
       +
       <div>

     

       5
       21
        
         <div class="flex justify-between items-center">

     

       6
       6
       -
           <h1 class="text-xl font-bold dark:text-white">{{ .Spindle.Instance }}</h1>

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">{{ .Tab }} &middot; {{ .Spindle.Instance }}</h2>

     

       7
       23
        
           <div id="right-side" class="flex gap-2">

     

       8
       24
        
             {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       9
       25
        
             {{ $isOwner := and .LoggedInUser (eq .LoggedInUser.Did .Spindle.Owner)  }}

     
···

       71
       87
        
         <button

     

       72
       88
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       73
       89
        
           title="Delete spindle"

     

       74
       74
       -
           hx-delete="/spindles/{{ .Instance }}"

     

       90
       90
       +
           hx-delete="/settings/spindles/{{ .Instance }}"

     

       75
       91
        
           hx-swap="outerHTML"

     

       76
       92
        
           hx-confirm="Are you sure you want to delete the spindle '{{ .Instance }}'?"

     

       77
       93
        
           hx-headers='{"shouldRedirect": "true"}'

     
···

       87
       103
        
         <button

     

       88
       104
        
           class="btn gap-2 group"

     

       89
       105
        
           title="Retry spindle verification"

     

       90
       90
       -
           hx-post="/spindles/{{ .Instance }}/retry"

     

       106
       106
       +
           hx-post="/settings/spindles/{{ .Instance }}/retry"

     

       91
       107
        
           hx-swap="none"

     

       92
       108
        
           hx-headers='{"shouldRefresh": "true"}'

     

       93
       109
        
         >

     
···

       104
       120
        
           <button

     

       105
       121
        
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       106
       122
        
             title="Remove member"

     

       107
       107
       -
             hx-post="/spindles/{{ $root.Spindle.Instance }}/remove"

     

       123
       123
       +
             hx-post="/settings/spindles/{{ $root.Spindle.Instance }}/remove"

     

       108
       124
        
             hx-swap="none"

     

       109
       125
        
             hx-vals='{"member": "{{$member}}" }'

     

       110
       126
        
             hx-confirm="Are you sure you want to remove {{ resolve $member }} from this instance?"

+17 -9

appview/pages/templates/spindles/fragments/addMemberModal.html

···

       13
       13
        
         <div

     

       14
       14
        
           id="add-member-{{ .Instance }}"

     

       15
       15
        
           popover

     

       16
       16
       -
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       16
       16
       +
           class="

     

       17
       17
       +
           bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50

     

       18
       18
       +
           w-full md:w-96 p-4 rounded drop-shadow overflow-visible">

     

       17
       19
        
           {{ block "addSpindleMemberPopover" . }} {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     

       20
       22
        
       

     

       21
       23
        
       {{ define "addSpindleMemberPopover" }}

     

       22
       24
        
       <form

     

       23
       23
       -
         hx-post="/spindles/{{ .Instance }}/add"

     

       25
       25
       +
         hx-post="/settings/spindles/{{ .Instance }}/add"

     

       24
       26
        
         hx-indicator="#spinner"

     

       25
       27
        
         hx-swap="none"

     

       26
       28
        
         class="flex flex-col gap-2"

     
···

       29
       31
        
           ADD MEMBER

     

       30
       32
        
         </label>

     

       31
       33
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can register repositories and run workflows on this spindle.</p>

     

       32
       32
       -
         <input

     

       33
       33
       -
           type="text"

     

       34
       34
       -
           id="member-did-{{ .Id }}"

     

       35
       35
       -
           name="member"

     

       36
       36
       -
           required

     

       37
       37
       -
           placeholder="@foo.bsky.social"

     

       38
       38
       -
         />

     

       34
       34
       +
         <actor-typeahead>

     

       35
       35
       +
           <input

     

       36
       36
       +
             autocapitalize="none"

     

       37
       37
       +
             autocorrect="off"

     

       38
       38
       +
             autocomplete="off"

     

       39
       39
       +
             type="text"

     

       40
       40
       +
             id="member-did-{{ .Id }}"

     

       41
       41
       +
             name="member"

     

       42
       42
       +
             required

     

       43
       43
       +
             placeholder="user.tngl.sh"

     

       44
       44
       +
             class="w-full"

     

       45
       45
       +
           />

     

       46
       46
       +
         </actor-typeahead>

     

       39
       47
        
         <div class="flex gap-2 pt-2">

     

       40
       48
        
           <button 

     

       41
       49
        
             type="button"

+3 -3

appview/pages/templates/spindles/fragments/spindleListing.html

···

       7
       7
        
       

     

       8
       8
        
       {{ define "spindleLeftSide" }}

     

       9
       9
        
         {{ if .Verified }}

     

       10
       10
       -
         <a href="/spindles/{{ .Instance }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       10
       10
       +
         <a href="/settings/spindles/{{ .Instance }}" class="hover:no-underline flex items-center gap-2 min-w-0 max-w-[60%]">

     

       11
       11
        
           {{ i "hard-drive" "w-4 h-4" }}

     

       12
       12
        
           <span class="hover:underline">

     

       13
       13
        
             {{ .Instance }}

     
···

       50
       50
        
         <button

     

       51
       51
        
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       52
       52
        
           title="Delete spindle"

     

       53
       53
       -
           hx-delete="/spindles/{{ .Instance }}"

     

       53
       53
       +
           hx-delete="/settings/spindles/{{ .Instance }}"

     

       54
       54
        
           hx-swap="outerHTML"

     

       55
       55
        
           hx-target="#spindle-{{.Id}}"

     

       56
       56
        
           hx-confirm="Are you sure you want to delete the spindle '{{ .Instance }}'?"

     
···

       66
       66
        
         <button

     

       67
       67
        
           class="btn gap-2 group"

     

       68
       68
        
           title="Retry spindle verification"

     

       69
       69
       -
           hx-post="/spindles/{{ .Instance }}/retry"

     

       69
       69
       +
           hx-post="/settings/spindles/{{ .Instance }}/retry"

     

       70
       70
        
           hx-swap="none"

     

       71
       71
        
           hx-target="#spindle-{{.Id}}"

     

       72
       72
        
         >

+90 -59

appview/pages/templates/spindles/index.html

···

       1
       1
       -
       {{ define "title" }}spindles{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .Tab }} settings{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "content" }}

     

       4
       4
       -
       <div class="px-6 py-4 flex items-center justify-between gap-4 align-bottom">

     

       5
       5
       -
           <h1 class="text-xl font-bold dark:text-white">Spindles</h1>

     

       6
       6
       -
           <span class="flex items-center gap-1">

     

       7
       7
       -
               {{ i "book" "w-3 h-3" }}

     

       8
       8
       -
               <a href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">docs</a>

     

       9
       9
       -
           </span>

     

       4
       4
       +
         <div class="p-6">

     

       5
       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       6
       +
         </div>

     

       7
       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       9
       +
             <div class="col-span-1">

     

       10
       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       11
       +
             </div>

     

       12
       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       13
       +
               {{ template "spindleList" . }}

     

       14
       14
       +
             </div>

     

       15
       15
       +
           </section>

     

       16
       16
       +
         </div>

     

       17
       17
       +
       {{ end }}

     

       18
       18
       +
       

     

       19
       19
       +
       {{ define "spindleList" }}

     

       20
       20
       +
       <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       21
       21
       +
         <div class="col-span-1 md:col-span-2">

     

       22
       22
       +
           <h2 class="text-sm pb-2 uppercase font-bold">Spindle</h2>

     

       23
       23
       +
           {{ block "about" . }} {{ end }}

     

       24
       24
       +
         </div>

     

       25
       25
       +
         <div class="col-span-1 md:col-span-1 md:justify-self-end">

     

       26
       26
       +
           {{ template "docsButton" . }}

     

       27
       27
       +
         </div>

     

       10
       28
        
       </div>

     

       11
       29
        
       

     

       12
       12
       -
       <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       30
       30
       +
       <section>

     

       13
       31
        
         <div class="flex flex-col gap-6">

     

       14
       14
       -
           {{ block "about" . }} {{ end }}

     

       15
       32
        
           {{ block "list" . }} {{ end }}

     

       16
       33
        
           {{ block "register" . }} {{ end }}

     

       17
       34
        
         </div>

     
···

       20
       37
        
       

     

       21
       38
        
       {{ define "about" }}

     

       22
       39
        
       <section class="rounded flex items-center gap-2">

     

       23
       23
       -
           <p class="text-gray-500 dark:text-gray-400">

     

       24
       24
       -
               Spindles are small CI runners.

     

       25
       25
       -
           </p>

     

       40
       40
       +
         <p class="text-gray-500 dark:text-gray-400">

     

       41
       41
       +
           Spindles are small CI runners.

     

       42
       42
       +
         </p>

     

       26
       43
        
       </section>

     

       27
       44
        
       {{ end }}

     

       28
       45
        
       

     

       29
       46
        
       {{ define "list" }}

     

       30
       30
       -
         <section class="rounded w-full flex flex-col gap-2">

     

       31
       31
       -
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">your spindles</h2>

     

       32
       32
       -
           <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 w-full">

     

       33
       33
       -
             {{ range $spindle := .Spindles }}

     

       34
       34
       -
               {{ template "spindles/fragments/spindleListing" . }}

     

       35
       35
       -
             {{ else }}

     

       36
       36
       -
               <div class="flex items-center justify-center p-2 border-b border-gray-200 dark:border-gray-700 text-gray-500">

     

       37
       37
       -
                 no spindles registered yet

     

       38
       38
       -
               </div>

     

       39
       39
       -
             {{ end }}

     

       47
       47
       +
       <section class="rounded w-full flex flex-col gap-2">

     

       48
       48
       +
         <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">your spindles</h2>

     

       49
       49
       +
         <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 w-full">

     

       50
       50
       +
           {{ range $spindle := .Spindles }}

     

       51
       51
       +
           {{ template "spindles/fragments/spindleListing" . }}

     

       52
       52
       +
           {{ else }}

     

       53
       53
       +
           <div class="flex items-center justify-center p-2 border-b border-gray-200 dark:border-gray-700 text-gray-500">

     

       54
       54
       +
             no spindles registered yet

     

       40
       55
        
           </div>

     

       41
       41
       -
           <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       42
       42
       -
         </section>

     

       56
       56
       +
           {{ end }}

     

       57
       57
       +
         </div>

     

       58
       58
       +
         <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       59
       59
       +
       </section>

     

       43
       60
        
       {{ end }}

     

       44
       61
        
       

     

       45
       62
        
       {{ define "register" }}

     

       46
       46
       -
         <section class="rounded w-full lg:w-fit flex flex-col gap-2">

     

       47
       47
       -
           <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a spindle</h2>

     

       48
       48
       -
           <p class="mb-2 dark:text-gray-300">Enter the hostname of your spindle to get started.</p>

     

       49
       49
       -
           <form

     

       50
       50
       -
             hx-post="/spindles/register"

     

       51
       51
       -
             class="max-w-2xl mb-2 space-y-4"

     

       52
       52
       -
             hx-indicator="#register-button"

     

       53
       53
       -
             hx-swap="none"

     

       54
       54
       -
             >

     

       55
       55
       -
             <div class="flex gap-2">

     

       56
       56
       -
               <input

     

       57
       57
       -
                 type="text"

     

       58
       58
       -
                 id="instance"

     

       59
       59
       -
                 name="instance"

     

       60
       60
       -
                 placeholder="spindle.example.com"

     

       61
       61
       -
                 required

     

       62
       62
       -
                 class="flex-1 w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

     

       63
       63
       -
               >

     

       64
       64
       -
               <button

     

       65
       65
       -
                 type="submit"

     

       66
       66
       -
                 id="register-button"

     

       67
       67
       -
                 class="btn rounded flex items-center py-2 dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 group"

     

       68
       68
       -
                 >

     

       69
       69
       -
                 <span class="inline-flex items-center gap-2">

     

       70
       70
       -
                   {{ i "plus" "w-4 h-4" }}

     

       71
       71
       -
                   register

     

       72
       72
       -
                 </span>

     

       73
       73
       -
                 <span class="pl-2 hidden group-[.htmx-request]:inline">

     

       74
       74
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin" }}

     

       75
       75
       -
                 </span>

     

       76
       76
       -
               </button>

     

       77
       77
       -
             </div>

     

       63
       63
       +
       <section class="rounded w-full lg:w-fit flex flex-col gap-2">

     

       64
       64
       +
         <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">register a spindle</h2>

     

       65
       65
       +
         <p class="mb-2 dark:text-gray-300">Enter the hostname of your spindle to get started.</p>

     

       66
       66
       +
         <form

     

       67
       67
       +
         hx-post="/settings/spindles/register"

     

       68
       68
       +
         class="max-w-2xl mb-2 space-y-4"

     

       69
       69
       +
         hx-indicator="#register-button"

     

       70
       70
       +
         hx-swap="none"

     

       71
       71
       +
         >

     

       72
       72
       +
         <div class="flex gap-2">

     

       73
       73
       +
           <input

     

       74
       74
       +
           type="text"

     

       75
       75
       +
           id="instance"

     

       76
       76
       +
           name="instance"

     

       77
       77
       +
           placeholder="spindle.example.com"

     

       78
       78
       +
           required

     

       79
       79
       +
           class="flex-1 w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

     

       80
       80
       +
           >

     

       81
       81
       +
           <button

     

       82
       82
       +
           type="submit"

     

       83
       83
       +
           id="register-button"

     

       84
       84
       +
           class="btn rounded flex items-center py-2 dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 group"

     

       85
       85
       +
           >

     

       86
       86
       +
           <span class="inline-flex items-center gap-2">

     

       87
       87
       +
             {{ i "plus" "w-4 h-4" }}

     

       88
       88
       +
             register

     

       89
       89
       +
           </span>

     

       90
       90
       +
           <span class="pl-2 hidden group-[.htmx-request]:inline">

     

       91
       91
       +
             {{ i "loader-circle" "w-4 h-4 animate-spin" }}

     

       92
       92
       +
           </span>

     

       93
       93
       +
         </button>

     

       94
       94
       +
       </div>

     

       78
       95
        
       

     

       79
       79
       -
             <div id="register-error" class="dark:text-red-400"></div>

     

       80
       80
       -
           </form>

     

       96
       96
       +
       <div id="register-error" class="dark:text-red-400"></div>

     

       97
       97
       +
       </form>

     

       98
       98
       +
       

     

       99
       99
       +
       </section>

     

       100
       100
       +
       {{ end }}

     

       81
       101
        
       

     

       82
       82
       -
         </section>

     

       102
       102
       +
       {{ define "docsButton" }}

     

       103
       103
       +
       <a

     

       104
       104
       +
       class="btn flex items-center gap-2"

     

       105
       105
       +
       href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">

     

       106
       106
       +
       {{ i "book" "size-4" }}

     

       107
       107
       +
       docs

     

       108
       108
       +
       </a>

     

       109
       109
       +
       <div

     

       110
       110
       +
       id="add-email-modal"

     

       111
       111
       +
       popover

     

       112
       112
       +
       class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       113
       113
       +
       </div>

     

       83
       114
        
       {{ end }}

+6 -5

appview/pages/templates/strings/dashboard.html

···

       1
       1
       -
       {{ define "title" }}strings by {{ or .Card.UserHandle .Card.UserDid  }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}strings by {{ resolve .Card.UserDid  }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       4
       4
       +
           {{ $handle := resolve .Card.UserDid }}

     

       5
       5
       +
           <meta property="og:title" content="{{ $handle }}" />

     

       5
       6
        
           <meta property="og:type" content="profile" />

     

       6
       6
       -
           <meta property="og:url" content="https://tangled.org/{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       7
       7
       -
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       7
       7
       +
           <meta property="og:url" content="https://tangled.org/{{ $handle }}" />

     

       8
       8
       +
           <meta property="og:description" content="{{ or .Card.Profile.Description $handle }}" />

     

       8
       9
        
       {{ end }}

     

       9
       10
        
       

     

       10
       11
        
       

     
···

       35
       36
        
         {{ $s := index . 1 }}

     

       36
       37
        
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800">

     

       37
       38
        
           <div class="font-medium dark:text-white flex gap-2 items-center">

     

       38
       38
       -
               <a href="/strings/{{ or $root.Card.UserHandle $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       39
       39
       +
               <a href="/strings/{{ resolve $root.Card.UserDid }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       39
       40
        
           </div>

     

       40
       41
        
           {{ with $s.Description }}

     

       41
       42
        
             <div class="text-gray-600 dark:text-gray-300 text-sm">

+14 -10

appview/pages/templates/strings/string.html

···

       1
       1
       -
       {{ define "title" }}{{ .String.Filename }} · by {{ didOrHandle .Owner.DID.String .Owner.Handle.String }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ .String.Filename }} · by {{ resolve .Owner.DID.String }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "extrameta" }}

     

       4
       4
       -
         {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       4
       4
       +
         {{ $ownerId := resolve .Owner.DID.String }}

     

       5
       5
        
         <meta property="og:title" content="{{ .String.Filename }} · by {{ $ownerId }}" />

     

       6
       6
        
         <meta property="og:type" content="object" />

     

       7
       7
        
         <meta property="og:url" content="https://tangled.org/strings/{{ $ownerId }}/{{ .String.Rkey }}" />

     
···

       9
       9
        
       {{ end }}

     

       10
       10
        
       

     

       11
       11
        
       {{ define "content" }}

     

       12
       12
       -
       {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       12
       12
       +
       {{ $ownerId := resolve .Owner.DID.String }}

     

       13
       13
        
         <section id="string-header" class="mb-4 py-2 px-6 dark:text-white">

     

       14
       14
        
           <div class="text-lg flex items-center justify-between">

     

       15
       15
        
             <div>

     
···

       17
       17
        
               <span class="select-none">/</span>

     

       18
       18
        
               <a href="/strings/{{ $ownerId }}/{{ .String.Rkey }}" class="font-bold">{{ .String.Filename }}</a>

     

       19
       19
        
             </div>

     

       20
       20
       -
             {{ if and .LoggedInUser (eq .LoggedInUser.Did .String.Did) }}

     

       21
       21
       -
               <div class="flex gap-2 text-base">

     

       20
       20
       +
             <div class="flex gap-2 text-base">

     

       21
       21
       +
               {{ if and .LoggedInUser (eq .LoggedInUser.Did .String.Did) }}

     

       22
       22
        
                 <a class="btn flex items-center gap-2 no-underline hover:no-underline p-2 group"

     

       23
       23
        
                    hx-boost="true"

     

       24
       24
        
                    href="/strings/{{ .String.Did }}/{{ .String.Rkey }}/edit">

     
···

       37
       37
        
                   <span class="hidden md:inline">delete</span>

     

       38
       38
        
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       39
       39
        
                 </button>

     

       40
       40
       -
               </div>

     

       41
       41
       -
             {{ end }}

     

       40
       40
       +
               {{ end }}

     

       41
       41
       +
               {{ template "fragments/starBtn"

     

       42
       42
       +
                 (dict "SubjectAt" .String.AtUri

     

       43
       43
       +
                       "IsStarred" .IsStarred

     

       44
       44
       +
                       "StarCount" .StarCount) }}

     

       45
       45
       +
             </div>

     

       42
       46
        
           </div>

     

       43
       47
        
           <span>

     

       44
       48
        
             {{ with .String.Description }}

     
···

       47
       51
        
           </span>

     

       48
       52
        
         </section>

     

       49
       53
        
         <section class="bg-white dark:bg-gray-800 px-6 py-4 rounded relative w-full dark:text-white">

     

       50
       50
       -
           <div class="flex justify-between items-center text-gray-500 dark:text-gray-400 text-sm md:text-base pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700">

     

       54
       54
       +
           <div class="flex flex-col md:flex-row md:justify-between md:items-center text-gray-500 dark:text-gray-400 text-sm md:text-base pb-2 mb-3 text-base border-b border-gray-200 dark:border-gray-700">

     

       51
       55
        
             <span>

     

       52
       56
        
               {{ .String.Filename }}

     

       53
       57
        
               <span class="select-none px-1 md:px-2 [&:before]:content-['·']"></span>

     
···

       75
       79
        
           </div>

     

       76
       80
        
           <div class="overflow-x-auto overflow-y-hidden relative">

     

       77
       81
        
             {{ if .ShowRendered }}

     

       78
       78
       -
             <div id="blob-contents" class="prose dark:prose-invert">{{ .RenderedContents }}</div>

     

       82
       82
       +
               <div id="blob-contents" class="prose dark:prose-invert">{{ .String.Contents | readme }}</div>

     

       79
       83
        
             {{ else }}

     

       80
       80
       -
             <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ .String.Contents | escapeHtml }}</div>

     

       84
       84
       +
               <div id="blob-contents" class="whitespace-pre peer-target:bg-yellow-200 dark:peer-target:bg-yellow-900">{{ code .String.Contents .String.Filename | escapeHtml }}</div>

     

       81
       85
        
             {{ end }}

     

       82
       86
        
           </div>

     

       83
       87
        
           {{ template "fragments/multiline-select" }}

+1 -2

appview/pages/templates/timeline/fragments/goodfirstissues.html

···

       3
       3
        
           <a href="/goodfirstissues" class="no-underline hover:no-underline">

     

       4
       4
        
             <div class="flex items-center justify-between gap-2 bg-purple-200 dark:bg-purple-900 border border-purple-400 dark:border-purple-500 rounded mb-4 py-4 px-6 ">

     

       5
       5
        
               <div class="flex-1 flex flex-col gap-2">

     

       6
       6
       -
                 <div class="text-purple-500 dark:text-purple-400">Oct 2025</div>

     

       7
       6
        
                 <p>

     

       8
       8
       -
                   Make your first contribution to an open-source project this October.

     

       7
       7
       +
                   Make your first contribution to an open-source project.

     

       9
       8
        
                   <em>good-first-issue</em> helps new contributors find easy ways to

     

       10
       9
        
                   start contributing to open-source projects.

     

       11
       10
        
                 </p>

+2 -2

appview/pages/templates/timeline/fragments/hero.html

···

       4
       4
        
                   <h1 class="font-bold text-4xl">tightly-knit<br>social coding.</h1>

     

       5
       5
        
       

     

       6
       6
        
                   <p class="text-lg">

     

       7
       7
       -
                     tangled is new social-enabled git collaboration platform built on <a class="underline" href="https://atproto.com/">atproto</a>.

     

       7
       7
       +
                       Tangled is a decentralized Git hosting and collaboration platform.

     

       8
       8
        
                   </p>

     

       9
       9
        
                   <p class="text-lg">

     

       10
       10
       -
                     we envision a place where developers have complete ownership of their

     

       10
       10
       +
                     We envision a place where developers have complete ownership of their

     

       11
       11
        
                     code, open source communities can freely self-govern and most

     

       12
       12
        
                     importantly, coding can be social and fun again.

     

       13
       13
        
                   </p>

+5 -5

appview/pages/templates/timeline/fragments/timeline.html

···

       14
       14
        
                       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       15
       15
        
                         {{ if .Repo }}

     

       16
       16
        
                           {{ template "timeline/fragments/repoEvent" (list $ .) }}

     

       17
       17
       -
                         {{ else if .Star }}

     

       17
       17
       +
                         {{ else if .RepoStar }}

     

       18
       18
        
                           {{ template "timeline/fragments/starEvent" (list $ .) }}

     

       19
       19
        
                         {{ else if .Follow }}

     

       20
       20
        
                           {{ template "timeline/fragments/followEvent" (list $ .) }}

     
···

       52
       52
        
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $repo.Created }}</span>

     

       53
       53
        
           </div>

     

       54
       54
        
         {{ with $repo }}

     

       55
       55
       -
           {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "RepoAt" .RepoAt "Stats" (dict "StarCount" $event.StarCount))) }}

     

       55
       55
       +
           {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "SubjectAt" .RepoAt "StarCount" $event.StarCount)) }}

     

       56
       56
        
         {{ end }}

     

       57
       57
        
       {{ end }}

     

       58
       58
        
       

     

       59
       59
        
       {{ define "timeline/fragments/starEvent" }}

     

       60
       60
        
         {{ $root := index . 0 }}

     

       61
       61
        
         {{ $event := index . 1 }}

     

       62
       62
       -
         {{ $star := $event.Star }}

     

       62
       62
       +
         {{ $star := $event.RepoStar }}

     

       63
       63
        
         {{ with $star }}

     

       64
       64
       -
           {{ $starrerHandle :=  resolve .StarredByDid }}

     

       64
       64
       +
           {{ $starrerHandle := resolve .Did }}

     

       65
       65
        
           {{ $repoOwnerHandle :=  resolve .Repo.Did }}

     

       66
       66
        
           <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       67
       67
        
               {{ template "user/fragments/picHandleLink" $starrerHandle }}

     
···

       72
       72
        
               <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" .Created }}</span>

     

       73
       73
        
           </div>

     

       74
       74
        
           {{ with .Repo }}

     

       75
       75
       -
             {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "RepoAt" .RepoAt "Stats" (dict "StarCount" $event.StarCount))) }}

     

       75
       75
       +
             {{ template "user/fragments/repoCard" (list $root . true true (dict "IsStarred" $event.IsStarred "SubjectAt" .RepoAt "StarCount" $event.StarCount)) }}

     

       76
       76
        
           {{ end }}

     

       77
       77
        
         {{ end }}

     

       78
       78
        
       {{ end }}

+4 -2

appview/pages/templates/user/followers.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · followers {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · followers {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-followers" class="md:col-span-8 order-2 md:order-2">

     
···

       19
       19
        
                     "FollowersCount" .FollowersCount

     

       20
       20
        
                     "FollowingCount" .FollowingCount) }}

     

       21
       21
        
           {{ else }}

     

       22
       22
       -
               <p class="px-6 dark:text-white">This user does not have any followers yet.</p>

     

       22
       22
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       23
       23
       +
                 <span>This user does not have any followers yet.</span>

     

       24
       24
       +
               </div>

     

       23
       25
        
           {{ end }}

     

       24
       26
        
         </div>

     

       25
       27
        
       {{ end }}

+4 -2

appview/pages/templates/user/following.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · following {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · following {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-following" class="md:col-span-8 order-2 md:order-2">

     
···

       19
       19
        
                     "FollowersCount" .FollowersCount

     

       20
       20
        
                     "FollowingCount" .FollowingCount) }}

     

       21
       21
        
           {{ else }}

     

       22
       22
       -
               <p class="px-6 dark:text-white">This user does not follow anyone yet.</p>

     

       22
       22
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       23
       23
       +
                 <span>This user does not follow anyone yet.</span>

     

       24
       24
       +
               </div>

     

       23
       25
        
           {{ end }}

     

       24
       26
        
         </div>

     

       25
       27
        
       {{ end }}

+17

appview/pages/templates/user/fragments/editBio.html

···

       20
       20
        
           </div>

     

       21
       21
        
       

     

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

     

       23
       23
       +
             <label class="m-0 p-0" for="pronouns">pronouns</label>

     

       24
       24
       +
             <div class="flex items-center gap-2 w-full">

     

       25
       25
       +
               {{ $pronouns := "" }}

     

       26
       26
       +
               {{ if and .Profile .Profile.Pronouns }}

     

       27
       27
       +
                 {{ $pronouns = .Profile.Pronouns }}

     

       28
       28
       +
               {{ end }}

     

       29
       29
       +
               <input

     

       30
       30
       +
                 type="text"

     

       31
       31
       +
                 class="py-1 px-1 w-full"

     

       32
       32
       +
                 name="pronouns"

     

       33
       33
       +
                 placeholder="they/them"

     

       34
       34
       +
                 value="{{ $pronouns }}"

     

       35
       35
       +
               >

     

       36
       36
       +
             </div>

     

       37
       37
       +
           </div>

     

       38
       38
       +
       

     

       39
       39
       +
           <div class="flex flex-col gap-1">

     

       23
       40
        
             <label class="m-0 p-0" for="location">location</label>

     

       24
       41
        
             <div class="flex items-center gap-2 w-full">

     

       25
       42
        
               {{ $location := "" }}

+1 -1

appview/pages/templates/user/fragments/followCard.html

···

       3
       3
        
       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 rounded-sm">

     

       4
       4
        
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4">

     

       5
       5
        
           <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       6
       6
       -
             <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" />

     

       6
       6
       +
             <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" alt="{{ $userIdent }}" />

     

       7
       7
        
           </div>

     

       8
       8
        
       

     

       9
       9
        
           <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-2 w-full">

+20 -7

appview/pages/templates/user/fragments/profileCard.html

···

       1
       1
        
       {{ define "user/fragments/profileCard" }}

     

       2
       2
       -
         {{ $userIdent := didOrHandle .UserDid .UserHandle }}

     

       2
       2
       +
         {{ $userIdent := resolve .UserDid }}

     

       3
       3
        
           <div class="grid grid-cols-3 md:grid-cols-1 gap-1 items-center">

     

       4
       4
        
             <div id="avatar" class="col-span-1 flex justify-center items-center">

     

       5
       5
        
               <div class="w-3/4 aspect-square relative">

     
···

       12
       12
        
                 class="text-lg font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">

     

       13
       13
        
                   {{ $userIdent }}

     

       14
       14
        
                 </p>

     

       15
       15
       -
                 <a href="/{{ $userIdent }}/feed.atom">{{ i "rss" "size-4" }}</a>

     

       15
       15
       +
                 {{ with .Profile }}

     

       16
       16
       +
                   {{ if .Pronouns }}

     

       17
       17
       +
                     <p class="text-gray-500 dark:text-gray-400">{{ .Pronouns }}</p>

     

       18
       18
       +
                   {{ end }}

     

       19
       19
       +
                 {{ end }}

     

       16
       20
        
               </div>

     

       17
       21
        
       

     

       18
       22
        
               <div class="md:hidden">

     
···

       67
       71
        
                   {{ end }}

     

       68
       72
        
                 </div>

     

       69
       73
        
                 {{ end }}

     

       70
       70
       -
                 {{ if ne .FollowStatus.String "IsSelf" }}

     

       71
       71
       -
                   {{ template "user/fragments/follow" . }}

     

       72
       72
       -
                 {{ else }}

     

       74
       74
       +
       

     

       75
       75
       +
                 <div class="flex mt-2 items-center gap-2">

     

       76
       76
       +
                   {{ if ne .FollowStatus.String "IsSelf" }}

     

       77
       77
       +
                     {{ template "user/fragments/follow" . }}

     

       78
       78
       +
                   {{ else }}

     

       73
       79
        
                   <button id="editBtn"

     

       74
       74
       -
                     class="btn mt-2 w-full flex items-center gap-2 group"

     

       80
       80
       +
                     class="btn w-full flex items-center gap-2 group"

     

       75
       81
        
                     hx-target="#profile-bio"

     

       76
       82
        
                     hx-get="/profile/edit-bio"

     

       77
       83
        
                     hx-swap="innerHTML">

     
···

       79
       85
        
                     edit

     

       80
       86
        
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       81
       87
        
                   </button>

     

       82
       82
       -
                 {{ end }}

     

       88
       88
       +
                   {{ end }}

     

       89
       89
       +
       

     

       90
       90
       +
                   <a class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       91
       91
       +
                     href="/{{ $userIdent }}/feed.atom">

     

       92
       92
       +
                     {{ i "rss" "size-4" }}

     

       93
       93
       +
                   </a>

     

       94
       94
       +
                 </div>

     

       95
       95
       +
       

     

       83
       96
        
               </div>

     

       84
       97
        
               <div id="update-profile" class="text-red-400 dark:text-red-500"></div>

     

       85
       98
        
             </div>

+2 -1

appview/pages/templates/user/fragments/repoCard.html

···

       1
       1
        
       {{ define "user/fragments/repoCard" }}

     

       2
       2
       +
         {{/* root, repo, fullName [,starButton [,starData]] */}}

     

       2
       3
        
         {{ $root := index . 0 }}

     

       3
       4
        
         {{ $repo := index . 1 }}

     

       4
       5
        
         {{ $fullName := index . 2 }}

     
···

       29
       30
        
               </div>

     

       30
       31
        
               {{ if and $starButton $root.LoggedInUser }}

     

       31
       32
        
               <div class="shrink-0">

     

       32
       32
       -
                 {{ template "repo/fragments/repoStar" $starData }}

     

       33
       33
       +
                 {{ template "fragments/starBtn" $starData }}

     

       33
       34
        
               </div>

     

       34
       35
        
               {{ end }}

     

       35
       36
        
             </div>

+23 -2

appview/pages/templates/user/login.html

···

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

     

       14
       14
        
               </head>

     

       15
       15
        
               <body class="flex items-center justify-center min-h-screen">

     

       16
       16
       -
                   <main class="max-w-md px-6 -mt-4">

     

       16
       16
       +
                   <main class="max-w-md px-7 mt-4">

     

       17
       17
        
                       <h1 class="flex place-content-center text-3xl font-semibold italic dark:text-white" >

     

       18
       18
        
                         {{ template "fragments/logotype" }}

     

       19
       19
        
                       </h1>

     
···

       21
       21
        
                           tightly-knit social coding.

     

       22
       22
        
                       </h2>

     

       23
       23
        
                       <form

     

       24
       24
       -
                           class="mt-4 max-w-sm mx-auto"

     

       24
       24
       +
                           class="mt-4"

     

       25
       25
        
                           hx-post="/login"

     

       26
       26
        
                           hx-swap="none"

     

       27
       27
        
                           hx-disabled-elt="#login-button"

     
···

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

     

       30
       30
        
                               <label for="handle">handle</label>

     

       31
       31
        
                               <input

     

       32
       32
       +
                                   autocapitalize="none"

     

       33
       33
       +
                                   autocorrect="off"

     

       34
       34
       +
                                   autocomplete="username"

     

       32
       35
        
                                   type="text"

     

       33
       36
        
                                   id="handle"

     

       34
       37
        
                                   name="handle"

     
···

       53
       56
        
                               <span>login</span>

     

       54
       57
        
                           </button>

     

       55
       58
        
                       </form>

     

       59
       59
       +
                       {{ if .ErrorCode }}

     

       60
       60
       +
                       <div class="flex gap-2 my-2 bg-red-50 dark:bg-red-900 border border-red-500 rounded drop-shadow-sm px-3 py-2 text-red-500 dark:text-red-300">

     

       61
       61
       +
                           <span class="py-1">{{ i "circle-alert" "w-4 h-4" }}</span>

     

       62
       62
       +
                           <div>

     

       63
       63
       +
                               <h5 class="font-medium">Login error</h5>

     

       64
       64
       +
                               <p class="text-sm">

     

       65
       65
       +
                               {{ if eq .ErrorCode "access_denied" }}

     

       66
       66
       +
                               You have not authorized the app.

     

       67
       67
       +
                               {{ else if eq .ErrorCode "session" }}

     

       68
       68
       +
                               Server failed to create user session.

     

       69
       69
       +
                               {{ else }}

     

       70
       70
       +
                               Internal Server error.

     

       71
       71
       +
                               {{ end }}

     

       72
       72
       +
                               Please try again.

     

       73
       73
       +
                               </p>

     

       74
       74
       +
                           </div>

     

       75
       75
       +
                       </div>

     

       76
       76
       +
                       {{ end }}

     

       56
       77
        
                       <p class="text-sm text-gray-500">

     

       57
       78
        
                         Don't have an account? <a href="/signup" class="underline">Create an account</a> on Tangled now!

     

       58
       79
        
                       </p>

+22 -4

appview/pages/templates/user/overview.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }}{{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }}{{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-4 order-2 md:order-2">

     
···

       16
       16
        
         <p class="text-sm font-bold px-2 pb-4 dark:text-white">ACTIVITY</p>

     

       17
       17
        
         <div class="flex flex-col gap-4 relative">

     

       18
       18
        
           {{ if .ProfileTimeline.IsEmpty }}

     

       19
       19
       -
             <p class="dark:text-white">This user does not have any activity yet.</p>

     

       19
       19
       +
             <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       20
       20
       +
               <span class="flex items-center gap-2">

     

       21
       21
       +
                 This user does not have any activity yet.

     

       22
       22
       +
               </span>

     

       23
       23
       +
             </div>

     

       20
       24
        
           {{ end }}

     

       21
       25
        
       

     

       22
       26
        
           {{ with .ProfileTimeline }}

     
···

       33
       37
        
                   </p>

     

       34
       38
        
       

     

       35
       39
        
                     <div class="flex flex-col gap-1">

     

       40
       40
       +
                       {{ block "commits"  .Commits }} {{ end }}

     

       36
       41
        
                       {{ block "repoEvents"  .RepoEvents }} {{ end }}

     

       37
       42
        
                       {{ block "issueEvents" .IssueEvents }} {{ end }}

     

       38
       43
        
                       {{ block "pullEvents"  .PullEvents }} {{ end }}

     
···

       43
       48
        
             {{ end }}

     

       44
       49
        
           {{ end }}

     

       45
       50
        
         </div>

     

       51
       51
       +
       {{ end }}

     

       52
       52
       +
       

     

       53
       53
       +
       {{ define "commits" }}

     

       54
       54
       +
         {{ if . }}

     

       55
       55
       +
           <div class="flex flex-wrap items-center gap-1">

     

       56
       56
       +
             {{ i "git-commit-horizontal" "size-5" }}

     

       57
       57
       +
             created {{ . }} commits

     

       58
       58
       +
           </div>

     

       59
       59
       +
         {{ end }}

     

       46
       60
        
       {{ end }}

     

       47
       61
        
       

     

       48
       62
        
       {{ define "repoEvents" }}

     
···

       224
       238
        
       {{ define "ownRepos" }}

     

       225
       239
        
         <div>

     

       226
       240
        
           <div class="text-sm font-bold px-2 pb-4 dark:text-white flex items-center gap-2">

     

       227
       227
       -
             <a href="/@{{ or $.Card.UserHandle $.Card.UserDid }}?tab=repos"

     

       241
       241
       +
             <a href="/{{ resolve $.Card.UserDid }}?tab=repos"

     

       228
       242
        
               class="flex text-black dark:text-white items-center gap-2 no-underline hover:no-underline group">

     

       229
       243
        
               <span>PINNED REPOS</span>

     

       230
       244
        
             </a>

     
···

       244
       258
        
               {{ template "user/fragments/repoCard" (list $ . false) }}

     

       245
       259
        
             </div>

     

       246
       260
        
             {{ else }}

     

       247
       247
       -
               <p class="dark:text-white">This user does not have any pinned repos.</p>

     

       261
       261
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       262
       262
       +
                 <span class="flex items-center gap-2">

     

       263
       263
       +
                   This user does not have any pinned repos.

     

       264
       264
       +
                 </span>

     

       265
       265
       +
               </div>

     

       248
       266
        
             {{ end }}

     

       249
       267
        
           </div>

     

       250
       268
        
         </div>

+4 -2

appview/pages/templates/user/repos.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · repos {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · repos {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
                {{ template "user/fragments/repoCard" (list $ . false) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
               <p class="px-6 dark:text-white">This user does not have any repos yet.</p>

     

       16
       16
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
                 <span>This user does not have any repos yet.</span>

     

       18
       18
       +
               </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

+14

appview/pages/templates/user/settings/notifications.html

···

       144
       144
        
             <div class="flex items-center justify-between p-2">

     

       145
       145
        
               <div class="flex items-center gap-2">

     

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

     

       147
       147
       +
                   <span class="font-bold">Mentions</span>

     

       148
       148
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       149
       149
       +
                     <span>When someone mentions you.</span>

     

       150
       150
       +
                   </div>

     

       151
       151
       +
                 </div>

     

       152
       152
       +
               </div>

     

       153
       153
       +
               <label class="flex items-center gap-2">

     

       154
       154
       +
                 <input type="checkbox" name="user_mentioned" {{if .Preferences.UserMentioned}}checked{{end}}>

     

       155
       155
       +
               </label>

     

       156
       156
       +
             </div>

     

       157
       157
       +
       

     

       158
       158
       +
             <div class="flex items-center justify-between p-2">

     

       159
       159
       +
               <div class="flex items-center gap-2">

     

       160
       160
       +
                 <div class="flex flex-col gap-1">

     

       147
       161
        
                   <span class="font-bold">Email notifications</span>

     

       148
       162
        
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       149
       163
        
                     <span>Receive notifications via email in addition to in-app notifications.</span>

+9 -6

appview/pages/templates/user/signup.html

···

       43
       43
        
                           page to complete your registration.

     

       44
       44
        
                           </span>

     

       45
       45
        
                           <div class="w-full mt-4 text-center">

     

       46
       46
       -
                             <div class="cf-turnstile" data-sitekey="{{ .CloudflareSiteKey }}"></div>

     

       46
       46
       +
                             <div class="cf-turnstile" data-sitekey="{{ .CloudflareSiteKey }}" data-size="flexible"></div>

     

       47
       47
        
                           </div>

     

       48
       48
        
                           <button class="btn text-base w-full my-2 mt-6" type="submit" id="signup-button" tabindex="7" >

     

       49
       49
        
                             <span>join now</span>

     

       50
       50
        
                           </button>

     

       51
       51
       +
                           <p class="text-sm text-gray-500">

     

       52
       52
       +
                             Already have an AT Protocol account? <a href="/login" class="underline">Login to Tangled</a>.

     

       53
       53
       +
                           </p>

     

       54
       54
       +
       

     

       55
       55
       +
                           <p id="signup-msg" class="error w-full"></p>

     

       56
       56
       +
                           <p class="text-sm text-gray-500 pt-4">

     

       57
       57
       +
                             By signing up, you agree to our <a href="/terms" class="underline">Terms of Service</a> and <a href="/privacy" class="underline">Privacy Policy</a>.

     

       58
       58
       +
                           </p>

     

       51
       59
        
                       </form>

     

       52
       52
       -
                       <p class="text-sm text-gray-500">

     

       53
       53
       -
                         Already have an AT Protocol account? <a href="/login" class="underline">Login to Tangled</a>.

     

       54
       54
       -
                       </p>

     

       55
       55
       -
       

     

       56
       56
       -
                       <p id="signup-msg" class="error w-full"></p>

     

       57
       60
        
                   </main>

     

       58
       61
        
               </body>

     

       59
       62
        
           </html>

+4 -2

appview/pages/templates/user/starred.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · repos {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · repos {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-repos" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
                {{ template "user/fragments/repoCard" (list $ . true) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
               <p class="px-6 dark:text-white">This user does not have any starred repos yet.</p>

     

       16
       16
       +
               <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
                 <span>This user does not have any starred repos yet.</span>

     

       18
       18
       +
               </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

+5 -3

appview/pages/templates/user/strings.html

···

       1
       1
       -
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · strings {{ end }}

     

       1
       1
       +
       {{ define "title" }}{{ resolve .Card.UserDid }} · strings {{ end }}

     

       2
       2
        
       

     

       3
       3
        
       {{ define "profileContent" }}

     

       4
       4
        
         <div id="all-strings" class="md:col-span-8 order-2 md:order-2">

     
···

       13
       13
        
               {{ template "singleString" (list $ .) }}

     

       14
       14
        
             </div>

     

       15
       15
        
           {{ else }}

     

       16
       16
       -
             <p class="px-6 dark:text-white">This user does not have any strings yet.</p>

     

       16
       16
       +
             <div class="text-base text-gray-500 flex items-center justify-center italic p-12 border border-gray-200 dark:border-gray-700 rounded">

     

       17
       17
       +
               <span>This user does not have any strings yet.</span>

     

       18
       18
       +
             </div>

     

       17
       19
        
           {{ end }}

     

       18
       20
        
         </div>

     

       19
       21
        
       {{ end }}

     
···

       23
       25
        
         {{ $s := index . 1 }}

     

       24
       26
        
         <div class="py-4 px-6 rounded bg-white dark:bg-gray-800">

     

       25
       27
        
           <div class="font-medium dark:text-white flex gap-2 items-center">

     

       26
       26
       -
               <a href="/strings/{{ or $root.Card.UserHandle $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       28
       28
       +
               <a href="/strings/{{ resolve $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       27
       29
        
           </div>

     

       28
       30
        
           {{ with $s.Description }}

     

       29
       31
        
             <div class="text-gray-600 dark:text-gray-300 text-sm">

+53 -35

appview/pipelines/pipelines.go

···

       16
       16
        
       	"tangled.org/core/appview/reporesolver"

     

       17
       17
        
       	"tangled.org/core/eventconsumer"

     

       18
       18
        
       	"tangled.org/core/idresolver"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	spindlemodel "tangled.org/core/spindle/models"

     

       21
       22
        
       

     
···

       33
       34
        
       	db            *db.DB

     

       34
       35
        
       	enforcer      *rbac.Enforcer

     

       35
       36
        
       	logger        *slog.Logger

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func (p *Pipelines) Router() http.Handler {

     

       40
       40
       +
       	r := chi.NewRouter()

     

       41
       41
       +
       	r.Get("/", p.Index)

     

       42
       42
       +
       	r.Get("/{pipeline}/workflow/{workflow}", p.Workflow)

     

       43
       43
       +
       	r.Get("/{pipeline}/workflow/{workflow}/logs", p.Logs)

     

       44
       44
       +
       

     

       45
       45
       +
       	return r

     

       36
       46
        
       }

     

       37
       47
        
       

     

       38
       48
        
       func New(

     
···

       69
       79
        
       		return

     

       70
       80
        
       	}

     

       71
       81
        
       

     

       72
       72
       -
       	repoInfo := f.RepoInfo(user)

     

       73
       73
       -
       

     

       74
       82
        
       	ps, err := db.GetPipelineStatuses(

     

       75
       83
        
       		p.db,

     

       76
       76
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       77
       77
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       78
       78
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       84
       84
       +
       		30,

     

       85
       85
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       86
       86
       +
       		orm.FilterEq("repo_name", f.Name),

     

       87
       87
       +
       		orm.FilterEq("knot", f.Knot),

     

       79
       88
        
       	)

     

       80
       89
        
       	if err != nil {

     

       81
       90
        
       		l.Error("failed to query db", "err", err)

     
···

       84
       93
        
       

     

       85
       94
        
       	p.pages.Pipelines(w, pages.PipelinesParams{

     

       86
       95
        
       		LoggedInUser: user,

     

       87
       87
       -
       		RepoInfo:     repoInfo,

     

       96
       96
       +
       		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       88
       97
        
       		Pipelines:    ps,

     

       89
       98
        
       	})

     

       90
       99
        
       }

     
···

       99
       108
        
       		return

     

       100
       109
        
       	}

     

       101
       110
        
       

     

       102
       102
       -
       	repoInfo := f.RepoInfo(user)

     

       103
       103
       -
       

     

       104
       111
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       105
       112
        
       	if pipelineId == "" {

     

       106
       113
        
       		l.Error("empty pipeline ID")

     
···

       115
       122
        
       

     

       116
       123
        
       	ps, err := db.GetPipelineStatuses(

     

       117
       124
        
       		p.db,

     

       118
       118
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       119
       119
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       120
       120
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       121
       121
       -
       		db.FilterEq("id", pipelineId),

     

       125
       125
       +
       		1,

     

       126
       126
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       127
       127
       +
       		orm.FilterEq("repo_name", f.Name),

     

       128
       128
       +
       		orm.FilterEq("knot", f.Knot),

     

       129
       129
       +
       		orm.FilterEq("id", pipelineId),

     

       122
       130
        
       	)

     

       123
       131
        
       	if err != nil {

     

       124
       132
        
       		l.Error("failed to query db", "err", err)

     
···

       134
       142
        
       

     

       135
       143
        
       	p.pages.Workflow(w, pages.WorkflowParams{

     

       136
       144
        
       		LoggedInUser: user,

     

       137
       137
       -
       		RepoInfo:     repoInfo,

     

       145
       145
       +
       		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       138
       146
        
       		Pipeline:     singlePipeline,

     

       139
       147
        
       		Workflow:     workflow,

     

       140
       148
        
       	})

     
···

       165
       173
        
       	ctx, cancel := context.WithCancel(r.Context())

     

       166
       174
        
       	defer cancel()

     

       167
       175
        
       

     

       168
       168
       -
       	user := p.oauth.GetUser(r)

     

       169
       176
        
       	f, err := p.repoResolver.Resolve(r)

     

       170
       177
        
       	if err != nil {

     

       171
       178
        
       		l.Error("failed to get repo and knot", "err", err)

     

       172
       179
        
       		http.Error(w, "bad repo/knot", http.StatusBadRequest)

     

       173
       180
        
       		return

     

       174
       181
        
       	}

     

       175
       175
       -
       

     

       176
       176
       -
       	repoInfo := f.RepoInfo(user)

     

       177
       182
        
       

     

       178
       183
        
       	pipelineId := chi.URLParam(r, "pipeline")

     

       179
       184
        
       	workflow := chi.URLParam(r, "workflow")

     
···

       184
       189
        
       

     

       185
       190
        
       	ps, err := db.GetPipelineStatuses(

     

       186
       191
        
       		p.db,

     

       187
       187
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       188
       188
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       189
       189
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       190
       190
       -
       		db.FilterEq("id", pipelineId),

     

       192
       192
       +
       		1,

     

       193
       193
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       194
       194
       +
       		orm.FilterEq("repo_name", f.Name),

     

       195
       195
       +
       		orm.FilterEq("knot", f.Knot),

     

       196
       196
       +
       		orm.FilterEq("id", pipelineId),

     

       191
       197
        
       	)

     

       192
       198
        
       	if err != nil || len(ps) != 1 {

     

       193
       199
        
       		l.Error("pipeline query failed", "err", err, "count", len(ps))

     
···

       196
       202
        
       	}

     

       197
       203
        
       

     

       198
       204
        
       	singlePipeline := ps[0]

     

       199
       199
       -
       	spindle := repoInfo.Spindle

     

       200
       200
       -
       	knot := repoInfo.Knot

     

       205
       205
       +
       	spindle := f.Spindle

     

       206
       206
       +
       	knot := f.Knot

     

       201
       207
        
       	rkey := singlePipeline.Rkey

     

       202
       208
        
       

     

       203
       209
        
       	if spindle == "" || knot == "" || rkey == "" {

     
···

       227
       233
        
       	// start a goroutine to read from spindle

     

       228
       234
        
       	go readLogs(spindleConn, evChan)

     

       229
       235
        
       

     

       230
       230
       -
       	stepIdx := 0

     

       236
       236
       +
       	stepStartTimes := make(map[int]time.Time)

     

       231
       237
        
       	var fragment bytes.Buffer

     

       232
       238
        
       	for {

     

       233
       239
        
       		select {

     
···

       259
       265
        
       

     

       260
       266
        
       			switch logLine.Kind {

     

       261
       267
        
       			case spindlemodel.LogKindControl:

     

       262
       262
       -
       				// control messages create a new step block

     

       263
       263
       -
       				stepIdx++

     

       264
       264
       -
       				collapsed := false

     

       265
       265
       -
       				if logLine.StepKind == spindlemodel.StepKindSystem {

     

       266
       266
       -
       					collapsed = true

     

       268
       268
       +
       				switch logLine.StepStatus {

     

       269
       269
       +
       				case spindlemodel.StepStatusStart:

     

       270
       270
       +
       					stepStartTimes[logLine.StepId] = logLine.Time

     

       271
       271
       +
       					collapsed := false

     

       272
       272
       +
       					if logLine.StepKind == spindlemodel.StepKindSystem {

     

       273
       273
       +
       						collapsed = true

     

       274
       274
       +
       					}

     

       275
       275
       +
       					err = p.pages.LogBlock(&fragment, pages.LogBlockParams{

     

       276
       276
       +
       						Id:        logLine.StepId,

     

       277
       277
       +
       						Name:      logLine.Content,

     

       278
       278
       +
       						Command:   logLine.StepCommand,

     

       279
       279
       +
       						Collapsed: collapsed,

     

       280
       280
       +
       						StartTime: logLine.Time,

     

       281
       281
       +
       					})

     

       282
       282
       +
       				case spindlemodel.StepStatusEnd:

     

       283
       283
       +
       					startTime := stepStartTimes[logLine.StepId]

     

       284
       284
       +
       					endTime := logLine.Time

     

       285
       285
       +
       					err = p.pages.LogBlockEnd(&fragment, pages.LogBlockEndParams{

     

       286
       286
       +
       						Id:        logLine.StepId,

     

       287
       287
       +
       						StartTime: startTime,

     

       288
       288
       +
       						EndTime:   endTime,

     

       289
       289
       +
       					})

     

       267
       290
        
       				}

     

       268
       268
       -
       				err = p.pages.LogBlock(&fragment, pages.LogBlockParams{

     

       269
       269
       -
       					Id:        stepIdx,

     

       270
       270
       -
       					Name:      logLine.Content,

     

       271
       271
       -
       					Command:   logLine.StepCommand,

     

       272
       272
       -
       					Collapsed: collapsed,

     

       273
       273
       -
       				})

     

       291
       291
       +
       

     

       274
       292
        
       			case spindlemodel.LogKindData:

     

       275
       293
        
       				// data messages simply insert new log lines into current step

     

       276
       294
        
       				err = p.pages.LogLine(&fragment, pages.LogLineParams{

     

       277
       277
       -
       					Id:      stepIdx,

     

       295
       295
       +
       					Id:      logLine.StepId,

     

       278
       296
        
       					Content: logLine.Content,

     

       279
       297
        
       				})

     

       280
       298
        
       			}

-17

appview/pipelines/router.go

···

       1
       1
       -
       package pipelines

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"net/http"

     

       5
       5
       -
       

     

       6
       6
       -
       	"github.com/go-chi/chi/v5"

     

       7
       7
       -
       	"tangled.org/core/appview/middleware"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       func (p *Pipelines) Router(mw *middleware.Middleware) http.Handler {

     

       11
       11
       -
       	r := chi.NewRouter()

     

       12
       12
       -
       	r.Get("/", p.Index)

     

       13
       13
       -
       	r.Get("/{pipeline}/workflow/{workflow}", p.Workflow)

     

       14
       14
       -
       	r.Get("/{pipeline}/workflow/{workflow}/logs", p.Logs)

     

       15
       15
       -
       

     

       16
       16
       -
       	return r

     

       17
       17
       -
       }

+10 -9

appview/pulls/opengraph.go

···

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

     

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

     

       15
       15
        
       	"tangled.org/core/appview/ogcard"

     

       16
       16
       +
       	"tangled.org/core/orm"

     

       16
       17
        
       	"tangled.org/core/patchutil"

     

       17
       18
        
       	"tangled.org/core/types"

     

       18
       19
        
       )

     
···

       146
       147
        
       	var statusColor color.RGBA

     

       147
       148
        
       

     

       148
       149
        
       	if pull.State.IsOpen() {

     

       149
       149
       -
       		statusIcon = "static/icons/git-pull-request.svg"

     

       150
       150
       +
       		statusIcon = "git-pull-request"

     

       150
       151
        
       		statusText = "open"

     

       151
       152
        
       		statusColor = color.RGBA{34, 139, 34, 255} // green

     

       152
       153
        
       	} else if pull.State.IsMerged() {

     

       153
       153
       -
       		statusIcon = "static/icons/git-merge.svg"

     

       154
       154
       +
       		statusIcon = "git-merge"

     

       154
       155
        
       		statusText = "merged"

     

       155
       156
        
       		statusColor = color.RGBA{138, 43, 226, 255} // purple

     

       156
       157
        
       	} else {

     

       157
       157
       -
       		statusIcon = "static/icons/git-pull-request-closed.svg"

     

       158
       158
       +
       		statusIcon = "git-pull-request-closed"

     

       158
       159
        
       		statusText = "closed"

     

       159
       160
        
       		statusColor = color.RGBA{128, 128, 128, 255} // gray

     

       160
       161
        
       	}

     
···

       162
       163
        
       	statusIconSize := 36

     

       163
       164
        
       

     

       164
       165
        
       	// Draw icon with status color

     

       165
       165
       -
       	err = statusStatsArea.DrawSVGIcon(statusIcon, statsX, statsY+iconBaselineOffset-statusIconSize/2+5, statusIconSize, statusColor)

     

       166
       166
       +
       	err = statusStatsArea.DrawLucideIcon(statusIcon, statsX, statsY+iconBaselineOffset-statusIconSize/2+5, statusIconSize, statusColor)

     

       166
       167
        
       	if err != nil {

     

       167
       168
        
       		log.Printf("failed to draw status icon: %v", err)

     

       168
       169
        
       	}

     
···

       179
       180
        
       	currentX := statsX + statusIconSize + 12 + statusTextWidth + 40

     

       180
       181
        
       

     

       181
       182
        
       	// Draw comment count

     

       182
       182
       -
       	err = statusStatsArea.DrawSVGIcon("static/icons/message-square.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       183
       183
       +
       	err = statusStatsArea.DrawLucideIcon("message-square", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       183
       184
        
       	if err != nil {

     

       184
       185
        
       		log.Printf("failed to draw comment icon: %v", err)

     

       185
       186
        
       	}

     
···

       198
       199
        
       	currentX += commentTextWidth + 40

     

       199
       200
        
       

     

       200
       201
        
       	// Draw files changed

     

       201
       201
       -
       	err = statusStatsArea.DrawSVGIcon("static/icons/file-diff.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       202
       202
       +
       	err = statusStatsArea.DrawLucideIcon("static/icons/file-diff", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       202
       203
        
       	if err != nil {

     

       203
       204
        
       		log.Printf("failed to draw file diff icon: %v", err)

     

       204
       205
        
       	}

     
···

       241
       242
        
       	dollyX := dollyBounds.Min.X + (dollyBounds.Dx() / 2) - (dollySize / 2)

     

       242
       243
        
       	dollyY := statsY + iconBaselineOffset - dollySize/2 + 25

     

       243
       244
        
       	dollyColor := color.RGBA{180, 180, 180, 255} // light gray

     

       244
       244
       -
       	err = dollyArea.DrawSVGIcon("templates/fragments/dolly/silhouette.svg", dollyX, dollyY, dollySize, dollyColor)

     

       245
       245
       +
       	err = dollyArea.DrawDollySilhouette(dollyX, dollyY, dollySize, dollyColor)

     

       245
       246
        
       	if err != nil {

     

       246
       247
        
       		log.Printf("dolly silhouette not available (this is ok): %v", err)

     

       247
       248
        
       	}

     
···

       276
       277
        
       	}

     

       277
       278
        
       

     

       278
       279
        
       	// Get comment count from database

     

       279
       279
       -
       	comments, err := db.GetPullComments(s.db, db.FilterEq("pull_id", pull.ID))

     

       280
       280
       +
       	comments, err := db.GetPullComments(s.db, orm.FilterEq("pull_id", pull.ID))

     

       280
       281
        
       	if err != nil {

     

       281
       282
        
       		log.Printf("failed to get pull comments: %v", err)

     

       282
       283
        
       	}

     
···

       293
       294
        
       		filesChanged = niceDiff.Stat.FilesChanged

     

       294
       295
        
       	}

     

       295
       296
        
       

     

       296
       296
       -
       	card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)

     

       297
       297
       +
       	card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)

     

       297
       298
        
       	if err != nil {

     

       298
       299
        
       		log.Println("failed to draw pull summary card", err)

     

       299
       300
        
       		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

+189 -139

appview/pulls/pulls.go

···

       1
       1
        
       package pulls

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"database/sql"

     

       5
       6
        
       	"encoding/json"

     

       6
       7
        
       	"errors"

     
···

       17
       18
        
       	"tangled.org/core/api/tangled"

     

       18
       19
        
       	"tangled.org/core/appview/config"

     

       19
       20
        
       	"tangled.org/core/appview/db"

     

       21
       21
       +
       	pulls_indexer "tangled.org/core/appview/indexer/pulls"

     

       22
       22
       +
       	"tangled.org/core/appview/mentions"

     

       20
       23
        
       	"tangled.org/core/appview/models"

     

       21
       24
        
       	"tangled.org/core/appview/notify"

     

       22
       25
        
       	"tangled.org/core/appview/oauth"

     

       23
       26
        
       	"tangled.org/core/appview/pages"

     

       24
       27
        
       	"tangled.org/core/appview/pages/markup"

     

       28
       28
       +
       	"tangled.org/core/appview/pages/repoinfo"

     

       25
       29
        
       	"tangled.org/core/appview/reporesolver"

     

       26
       30
        
       	"tangled.org/core/appview/validator"

     

       27
       31
        
       	"tangled.org/core/appview/xrpcclient"

     

       28
       32
        
       	"tangled.org/core/idresolver"

     

       33
       33
       +
       	"tangled.org/core/orm"

     

       29
       34
        
       	"tangled.org/core/patchutil"

     

       30
       35
        
       	"tangled.org/core/rbac"

     

       31
       36
        
       	"tangled.org/core/tid"

     

       32
       37
        
       	"tangled.org/core/types"

     

       33
       38
        
       

     

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

     

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

     

       35
       41
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       36
       42
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       37
       43
        
       	"github.com/go-chi/chi/v5"

     
···

       39
       45
        
       )

     

       40
       46
        
       

     

       41
       47
        
       type Pulls struct {

     

       42
       42
       -
       	oauth        *oauth.OAuth

     

       43
       43
       -
       	repoResolver *reporesolver.RepoResolver

     

       44
       44
       -
       	pages        *pages.Pages

     

       45
       45
       -
       	idResolver   *idresolver.Resolver

     

       46
       46
       -
       	db           *db.DB

     

       47
       47
       -
       	config       *config.Config

     

       48
       48
       -
       	notifier     notify.Notifier

     

       49
       49
       -
       	enforcer     *rbac.Enforcer

     

       50
       50
       -
       	logger       *slog.Logger

     

       51
       51
       -
       	validator    *validator.Validator

     

       48
       48
       +
       	oauth            *oauth.OAuth

     

       49
       49
       +
       	repoResolver     *reporesolver.RepoResolver

     

       50
       50
       +
       	pages            *pages.Pages

     

       51
       51
       +
       	idResolver       *idresolver.Resolver

     

       52
       52
       +
       	mentionsResolver *mentions.Resolver

     

       53
       53
       +
       	db               *db.DB

     

       54
       54
       +
       	config           *config.Config

     

       55
       55
       +
       	notifier         notify.Notifier

     

       56
       56
       +
       	enforcer         *rbac.Enforcer

     

       57
       57
       +
       	logger           *slog.Logger

     

       58
       58
       +
       	validator        *validator.Validator

     

       59
       59
       +
       	indexer          *pulls_indexer.Indexer

     

       52
       60
        
       }

     

       53
       61
        
       

     

       54
       62
        
       func New(

     
···

       56
       64
        
       	repoResolver *reporesolver.RepoResolver,

     

       57
       65
        
       	pages *pages.Pages,

     

       58
       66
        
       	resolver *idresolver.Resolver,

     

       67
       67
       +
       	mentionsResolver *mentions.Resolver,

     

       59
       68
        
       	db *db.DB,

     

       60
       69
        
       	config *config.Config,

     

       61
       70
        
       	notifier notify.Notifier,

     

       62
       71
        
       	enforcer *rbac.Enforcer,

     

       63
       72
        
       	validator *validator.Validator,

     

       73
       73
       +
       	indexer *pulls_indexer.Indexer,

     

       64
       74
        
       	logger *slog.Logger,

     

       65
       75
        
       ) *Pulls {

     

       66
       76
        
       	return &Pulls{

     

       67
       67
       -
       		oauth:        oauth,

     

       68
       68
       -
       		repoResolver: repoResolver,

     

       69
       69
       -
       		pages:        pages,

     

       70
       70
       -
       		idResolver:   resolver,

     

       71
       71
       -
       		db:           db,

     

       72
       72
       -
       		config:       config,

     

       73
       73
       -
       		notifier:     notifier,

     

       74
       74
       -
       		enforcer:     enforcer,

     

       75
       75
       -
       		logger:       logger,

     

       76
       76
       -
       		validator:    validator,

     

       77
       77
       +
       		oauth:            oauth,

     

       78
       78
       +
       		repoResolver:     repoResolver,

     

       79
       79
       +
       		pages:            pages,

     

       80
       80
       +
       		idResolver:       resolver,

     

       81
       81
       +
       		mentionsResolver: mentionsResolver,

     

       82
       82
       +
       		db:               db,

     

       83
       83
       +
       		config:           config,

     

       84
       84
       +
       		notifier:         notifier,

     

       85
       85
       +
       		enforcer:         enforcer,

     

       86
       86
       +
       		logger:           logger,

     

       87
       87
       +
       		validator:        validator,

     

       88
       88
       +
       		indexer:          indexer,

     

       77
       89
        
       	}

     

       78
       90
        
       }

     

       79
       91
        
       

     
···

       118
       130
        
       

     

       119
       131
        
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     

       120
       132
        
       			LoggedInUser:       user,

     

       121
       121
       -
       			RepoInfo:           f.RepoInfo(user),

     

       133
       133
       +
       			RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       122
       134
        
       			Pull:               pull,

     

       123
       135
        
       			RoundNumber:        roundNumber,

     

       124
       136
        
       			MergeCheck:         mergeCheckResponse,

     
···

       145
       157
        
       		return

     

       146
       158
        
       	}

     

       147
       159
        
       

     

       160
       160
       +
       	backlinks, err := db.GetBacklinks(s.db, pull.AtUri())

     

       161
       161
       +
       	if err != nil {

     

       162
       162
       +
       		log.Println("failed to get pull backlinks", err)

     

       163
       163
       +
       		s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")

     

       164
       164
       +
       		return

     

       165
       165
       +
       	}

     

       166
       166
       +
       

     

       148
       167
        
       	// can be nil  if this pull is not stacked

     

       149
       168
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       150
       169
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     
···

       156
       175
        
       		resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       157
       176
        
       	}

     

       158
       177
        
       

     

       159
       159
       -
       	repoInfo := f.RepoInfo(user)

     

       160
       160
       -
       

     

       161
       178
        
       	m := make(map[string]models.Pipeline)

     

       162
       179
        
       

     

       163
       180
        
       	var shas []string

     
···

       173
       190
        
       

     

       174
       191
        
       	ps, err := db.GetPipelineStatuses(

     

       175
       192
        
       		s.db,

     

       176
       176
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       177
       177
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       178
       178
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       179
       179
       -
       		db.FilterIn("sha", shas),

     

       193
       193
       +
       		len(shas),

     

       194
       194
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       195
       195
       +
       		orm.FilterEq("repo_name", f.Name),

     

       196
       196
       +
       		orm.FilterEq("knot", f.Knot),

     

       197
       197
       +
       		orm.FilterIn("sha", shas),

     

       180
       198
        
       	)

     

       181
       199
        
       	if err != nil {

     

       182
       200
        
       		log.Printf("failed to fetch pipeline statuses: %s", err)

     
···

       187
       205
        
       		m[p.Sha] = p

     

       188
       206
        
       	}

     

       189
       207
        
       

     

       190
       190
       -
       	reactionMap, err := db.GetReactionMap(s.db, 20, pull.PullAt())

     

       208
       208
       +
       	reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri())

     

       191
       209
        
       	if err != nil {

     

       192
       210
        
       		log.Println("failed to get pull reactions")

     

       193
       211
        
       		s.pages.Notice(w, "pulls", "Failed to load pull. Try again later.")

     
···

       195
       213
        
       

     

       196
       214
        
       	userReactions := map[models.ReactionKind]bool{}

     

       197
       215
        
       	if user != nil {

     

       198
       198
       -
       		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.PullAt())

     

       216
       216
       +
       		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.AtUri())

     

       199
       217
        
       	}

     

       200
       218
        
       

     

       201
       219
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       202
       220
        
       		s.db,

     

       203
       203
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       204
       204
       -
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       221
       221
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       222
       222
       +
       		orm.FilterContains("scope", tangled.RepoPullNSID),

     

       205
       223
        
       	)

     

       206
       224
        
       	if err != nil {

     

       207
       225
        
       		log.Println("failed to fetch labels", err)

     
···

       216
       234
        
       

     

       217
       235
        
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       218
       236
        
       		LoggedInUser:       user,

     

       219
       219
       -
       		RepoInfo:           repoInfo,

     

       237
       237
       +
       		RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       220
       238
        
       		Pull:               pull,

     

       221
       239
        
       		Stack:              stack,

     

       222
       240
        
       		AbandonedPulls:     abandonedPulls,

     

       241
       241
       +
       		Backlinks:          backlinks,

     

       223
       242
        
       		BranchDeleteStatus: branchDeleteStatus,

     

       224
       243
        
       		MergeCheck:         mergeCheckResponse,

     

       225
       244
        
       		ResubmitCheck:      resubmitResult,

     
···

       233
       252
        
       	})

     

       234
       253
        
       }

     

       235
       254
        
       

     

       236
       236
       -
       func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       255
       255
       +
       func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       237
       256
        
       	if pull.State == models.PullMerged {

     

       238
       257
        
       		return types.MergeCheckResponse{}

     

       239
       258
        
       	}

     
···

       262
       281
        
       		r.Context(),

     

       263
       282
        
       		&xrpcc,

     

       264
       283
        
       		&tangled.RepoMergeCheck_Input{

     

       265
       265
       -
       			Did:    f.OwnerDid(),

     

       284
       284
       +
       			Did:    f.Did,

     

       266
       285
        
       			Name:   f.Name,

     

       267
       286
        
       			Branch: pull.TargetBranch,

     

       268
       287
        
       			Patch:  patch,

     
···

       300
       319
        
       	return result

     

       301
       320
        
       }

     

       302
       321
        
       

     

       303
       303
       -
       func (s *Pulls) branchDeleteStatus(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull) *models.BranchDeleteStatus {

     

       322
       322
       +
       func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {

     

       304
       323
        
       	if pull.State != models.PullMerged {

     

       305
       324
        
       		return nil

     

       306
       325
        
       	}

     
···

       311
       330
        
       	}

     

       312
       331
        
       

     

       313
       332
        
       	var branch string

     

       314
       314
       -
       	var repo *models.Repo

     

       315
       333
        
       	// check if the branch exists

     

       316
       334
        
       	// NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates

     

       317
       335
        
       	if pull.IsBranchBased() {

     

       318
       336
        
       		branch = pull.PullSource.Branch

     

       319
       319
       -
       		repo = &f.Repo

     

       320
       337
        
       	} else if pull.IsForkBased() {

     

       321
       338
        
       		branch = pull.PullSource.Branch

     

       322
       339
        
       		repo = pull.PullSource.Repo

     
···

       355
       372
        
       	}

     

       356
       373
        
       }

     

       357
       374
        
       

     

       358
       358
       -
       func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       375
       375
       +
       func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       359
       376
        
       	if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {

     

       360
       377
        
       		return pages.Unknown

     

       361
       378
        
       	}

     
···

       375
       392
        
       		repoName = sourceRepo.Name

     

       376
       393
        
       	} else {

     

       377
       394
        
       		// pulls within the same repo

     

       378
       378
       -
       		knot = f.Knot

     

       379
       379
       -
       		ownerDid = f.OwnerDid()

     

       380
       380
       -
       		repoName = f.Name

     

       395
       395
       +
       		knot = repo.Knot

     

       396
       396
       +
       		ownerDid = repo.Did

     

       397
       397
       +
       		repoName = repo.Name

     

       381
       398
        
       	}

     

       382
       399
        
       

     

       383
       400
        
       	scheme := "http"

     
···

       389
       406
        
       		Host: host,

     

       390
       407
        
       	}

     

       391
       408
        
       

     

       392
       392
       -
       	repo := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       393
       393
       -
       	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo)

     

       409
       409
       +
       	didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       410
       410
       +
       	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)

     

       394
       411
        
       	if err != nil {

     

       395
       412
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       396
       413
        
       			log.Println("failed to call XRPC repo.branches", xrpcerr)

     
···

       418
       435
        
       

     

       419
       436
        
       func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {

     

       420
       437
        
       	user := s.oauth.GetUser(r)

     

       421
       421
       -
       	f, err := s.repoResolver.Resolve(r)

     

       422
       422
       -
       	if err != nil {

     

       423
       423
       -
       		log.Println("failed to get repo and knot", err)

     

       424
       424
       -
       		return

     

       425
       425
       -
       	}

     

       426
       438
        
       

     

       427
       439
        
       	var diffOpts types.DiffOpts

     

       428
       440
        
       	if d := r.URL.Query().Get("diff"); d == "split" {

     
···

       451
       463
        
       

     

       452
       464
        
       	s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{

     

       453
       465
        
       		LoggedInUser: user,

     

       454
       454
       -
       		RepoInfo:     f.RepoInfo(user),

     

       466
       466
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       455
       467
        
       		Pull:         pull,

     

       456
       468
        
       		Stack:        stack,

     

       457
       469
        
       		Round:        roundIdInt,

     
···

       465
       477
        
       func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {

     

       466
       478
        
       	user := s.oauth.GetUser(r)

     

       467
       479
        
       

     

       468
       468
       -
       	f, err := s.repoResolver.Resolve(r)

     

       469
       469
       -
       	if err != nil {

     

       470
       470
       -
       		log.Println("failed to get repo and knot", err)

     

       471
       471
       -
       		return

     

       472
       472
       -
       	}

     

       473
       473
       -
       

     

       474
       480
        
       	var diffOpts types.DiffOpts

     

       475
       481
        
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       476
       482
        
       		diffOpts.Split = true

     
···

       515
       521
        
       

     

       516
       522
        
       	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{

     

       517
       523
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       518
       518
       -
       		RepoInfo:     f.RepoInfo(user),

     

       524
       524
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       519
       525
        
       		Pull:         pull,

     

       520
       526
        
       		Round:        roundIdInt,

     

       521
       527
        
       		Interdiff:    interdiff,

     
···

       544
       550
        
       }

     

       545
       551
        
       

     

       546
       552
        
       func (s *Pulls) RepoPulls(w http.ResponseWriter, r *http.Request) {

     

       553
       553
       +
       	l := s.logger.With("handler", "RepoPulls")

     

       554
       554
       +
       

     

       547
       555
        
       	user := s.oauth.GetUser(r)

     

       548
       556
        
       	params := r.URL.Query()

     

       549
       557
        
       

     
···

       561
       569
        
       		return

     

       562
       570
        
       	}

     

       563
       571
        
       

     

       572
       572
       +
       	keyword := params.Get("q")

     

       573
       573
       +
       

     

       574
       574
       +
       	var ids []int64

     

       575
       575
       +
       	searchOpts := models.PullSearchOptions{

     

       576
       576
       +
       		Keyword: keyword,

     

       577
       577
       +
       		RepoAt:  f.RepoAt().String(),

     

       578
       578
       +
       		State:   state,

     

       579
       579
       +
       		// Page: page,

     

       580
       580
       +
       	}

     

       581
       581
       +
       	l.Debug("searching with", "searchOpts", searchOpts)

     

       582
       582
       +
       	if keyword != "" {

     

       583
       583
       +
       		res, err := s.indexer.Search(r.Context(), searchOpts)

     

       584
       584
       +
       		if err != nil {

     

       585
       585
       +
       			l.Error("failed to search for pulls", "err", err)

     

       586
       586
       +
       			return

     

       587
       587
       +
       		}

     

       588
       588
       +
       		ids = res.Hits

     

       589
       589
       +
       		l.Debug("searched pulls with indexer", "count", len(ids))

     

       590
       590
       +
       	} else {

     

       591
       591
       +
       		ids, err = db.GetPullIDs(s.db, searchOpts)

     

       592
       592
       +
       		if err != nil {

     

       593
       593
       +
       			l.Error("failed to get all pull ids", "err", err)

     

       594
       594
       +
       			return

     

       595
       595
       +
       		}

     

       596
       596
       +
       		l.Debug("indexed all pulls from the db", "count", len(ids))

     

       597
       597
       +
       	}

     

       598
       598
       +
       

     

       564
       599
        
       	pulls, err := db.GetPulls(

     

       565
       600
        
       		s.db,

     

       566
       566
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       567
       567
       -
       		db.FilterEq("state", state),

     

       601
       601
       +
       		orm.FilterIn("id", ids),

     

       568
       602
        
       	)

     

       569
       603
        
       	if err != nil {

     

       570
       604
        
       		log.Println("failed to get pulls", err)

     
···

       612
       646
        
       	}

     

       613
       647
        
       	pulls = pulls[:n]

     

       614
       648
        
       

     

       615
       615
       -
       	repoInfo := f.RepoInfo(user)

     

       616
       649
        
       	ps, err := db.GetPipelineStatuses(

     

       617
       650
        
       		s.db,

     

       618
       618
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       619
       619
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       620
       620
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       621
       621
       -
       		db.FilterIn("sha", shas),

     

       651
       651
       +
       		len(shas),

     

       652
       652
       +
       		orm.FilterEq("repo_owner", f.Did),

     

       653
       653
       +
       		orm.FilterEq("repo_name", f.Name),

     

       654
       654
       +
       		orm.FilterEq("knot", f.Knot),

     

       655
       655
       +
       		orm.FilterIn("sha", shas),

     

       622
       656
        
       	)

     

       623
       657
        
       	if err != nil {

     

       624
       658
        
       		log.Printf("failed to fetch pipeline statuses: %s", err)

     
···

       631
       665
        
       

     

       632
       666
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       633
       667
        
       		s.db,

     

       634
       634
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       635
       635
       -
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       668
       668
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       669
       669
       +
       		orm.FilterContains("scope", tangled.RepoPullNSID),

     

       636
       670
        
       	)

     

       637
       671
        
       	if err != nil {

     

       638
       672
        
       		log.Println("failed to fetch labels", err)

     
···

       647
       681
        
       

     

       648
       682
        
       	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       649
       683
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       650
       650
       -
       		RepoInfo:     f.RepoInfo(user),

     

       684
       684
       +
       		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       651
       685
        
       		Pulls:        pulls,

     

       652
       686
        
       		LabelDefs:    defs,

     

       653
       687
        
       		FilteringBy:  state,

     

       688
       688
       +
       		FilterQuery:  keyword,

     

       654
       689
        
       		Stacks:       stacks,

     

       655
       690
        
       		Pipelines:    m,

     

       656
       691
        
       	})

     
···

       683
       718
        
       	case http.MethodGet:

     

       684
       719
        
       		s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{

     

       685
       720
        
       			LoggedInUser: user,

     

       686
       686
       -
       			RepoInfo:     f.RepoInfo(user),

     

       721
       721
       +
       			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       687
       722
        
       			Pull:         pull,

     

       688
       723
        
       			RoundNumber:  roundNumber,

     

       689
       724
        
       		})

     
···

       695
       730
        
       			return

     

       696
       731
        
       		}

     

       697
       732
        
       

     

       733
       733
       +
       		mentions, references := s.mentionsResolver.Resolve(r.Context(), body)

     

       734
       734
       +
       

     

       698
       735
        
       		// Start a transaction

     

       699
       736
        
       		tx, err := s.db.BeginTx(r.Context(), nil)

     

       700
       737
        
       		if err != nil {

     
···

       718
       755
        
       			Rkey:       tid.TID(),

     

       719
       756
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       720
       757
        
       				Val: &tangled.RepoPullComment{

     

       721
       721
       -
       					Pull:      pull.PullAt().String(),

     

       758
       758
       +
       					Pull:      pull.AtUri().String(),

     

       722
       759
        
       					Body:      body,

     

       723
       760
        
       					CreatedAt: createdAt,

     

       724
       761
        
       				},

     
···

       737
       774
        
       			Body:         body,

     

       738
       775
        
       			CommentAt:    atResp.Uri,

     

       739
       776
        
       			SubmissionId: pull.Submissions[roundNumber].ID,

     

       777
       777
       +
       			Mentions:     mentions,

     

       778
       778
       +
       			References:   references,

     

       740
       779
        
       		}

     

       741
       780
        
       

     

       742
       781
        
       		// Create the pull comment in the database with the commentAt field

     
···

       754
       793
        
       			return

     

       755
       794
        
       		}

     

       756
       795
        
       

     

       757
       757
       -
       		s.notifier.NewPullComment(r.Context(), comment)

     

       796
       796
       +
       		s.notifier.NewPullComment(r.Context(), comment, mentions)

     

       758
       797
        
       

     

       759
       759
       -
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

     

       798
       798
       +
       		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       799
       799
       +
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))

     

       760
       800
        
       		return

     

       761
       801
        
       	}

     

       762
       802
        
       }

     
···

       780
       820
        
       			Host: host,

     

       781
       821
        
       		}

     

       782
       822
        
       

     

       783
       783
       -
       		repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       823
       823
       +
       		repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       784
       824
        
       		xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       785
       825
        
       		if err != nil {

     

       786
       826
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       807
       847
        
       

     

       808
       848
        
       		s.pages.RepoNewPull(w, pages.RepoNewPullParams{

     

       809
       849
        
       			LoggedInUser: user,

     

       810
       810
       -
       			RepoInfo:     f.RepoInfo(user),

     

       850
       850
       +
       			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       811
       851
        
       			Branches:     result.Branches,

     

       812
       852
        
       			Strategy:     strategy,

     

       813
       853
        
       			SourceBranch: sourceBranch,

     
···

       830
       870
        
       		}

     

       831
       871
        
       

     

       832
       872
        
       		// Determine PR type based on input parameters

     

       833
       833
       -
       		isPushAllowed := f.RepoInfo(user).Roles.IsPushAllowed()

     

       873
       873
       +
       		roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       874
       874
       +
       		isPushAllowed := roles.IsPushAllowed()

     

       834
       875
        
       		isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""

     

       835
       876
        
       		isForkBased := fromFork != "" && sourceBranch != ""

     

       836
       877
        
       		isPatchBased := patch != "" && !isBranchBased && !isForkBased

     
···

       928
       969
        
       func (s *Pulls) handleBranchBasedPull(

     

       929
       970
        
       	w http.ResponseWriter,

     

       930
       971
        
       	r *http.Request,

     

       931
       931
       -
       	f *reporesolver.ResolvedRepo,

     

       972
       972
       +
       	repo *models.Repo,

     

       932
       973
        
       	user *oauth.User,

     

       933
       974
        
       	title,

     

       934
       975
        
       	body,

     
···

       940
       981
        
       	if !s.config.Core.Dev {

     

       941
       982
        
       		scheme = "https"

     

       942
       983
        
       	}

     

       943
       943
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       984
       984
       +
       	host := fmt.Sprintf("%s://%s", scheme, repo.Knot)

     

       944
       985
        
       	xrpcc := &indigoxrpc.Client{

     

       945
       986
        
       		Host: host,

     

       946
       987
        
       	}

     

       947
       988
        
       

     

       948
       948
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       949
       949
       -
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)

     

       989
       989
       +
       	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       990
       990
       +
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)

     

       950
       991
        
       	if err != nil {

     

       951
       992
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       952
       993
        
       			log.Println("failed to call XRPC repo.compare", xrpcerr)

     
···

       983
       1024
        
       		Sha:    comparison.Rev2,

     

       984
       1025
        
       	}

     

       985
       1026
        
       

     

       986
       986
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1027
       1027
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       987
       1028
        
       }

     

       988
       1029
        
       

     

       989
       989
       -
       func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       1030
       1030
       +
       func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       990
       1031
        
       	if err := s.validator.ValidatePatch(&patch); err != nil {

     

       991
       1032
        
       		s.logger.Error("patch validation failed", "err", err)

     

       992
       1033
        
       		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       993
       1034
        
       		return

     

       994
       1035
        
       	}

     

       995
       1036
        
       

     

       996
       996
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       1037
       1037
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       997
       1038
        
       }

     

       998
       1039
        
       

     

       999
       999
       -
       func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       1040
       1040
       +
       func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       1000
       1041
        
       	repoString := strings.SplitN(forkRepo, "/", 2)

     

       1001
       1042
        
       	forkOwnerDid := repoString[0]

     

       1002
       1043
        
       	repoName := repoString[1]

     
···

       1098
       1139
        
       		Sha:    sourceRev,

     

       1099
       1140
        
       	}

     

       1100
       1141
        
       

     

       1101
       1101
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1142
       1142
       +
       	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       1102
       1143
        
       }

     

       1103
       1144
        
       

     

       1104
       1145
        
       func (s *Pulls) createPullRequest(

     

       1105
       1146
        
       	w http.ResponseWriter,

     

       1106
       1147
        
       	r *http.Request,

     

       1107
       1107
       -
       	f *reporesolver.ResolvedRepo,

     

       1148
       1148
       +
       	repo *models.Repo,

     

       1108
       1149
        
       	user *oauth.User,

     

       1109
       1150
        
       	title, body, targetBranch string,

     

       1110
       1151
        
       	patch string,

     
···

       1119
       1160
        
       		s.createStackedPullRequest(

     

       1120
       1161
        
       			w,

     

       1121
       1162
        
       			r,

     

       1122
       1122
       -
       			f,

     

       1163
       1163
       +
       			repo,

     

       1123
       1164
        
       			user,

     

       1124
       1165
        
       			targetBranch,

     

       1125
       1166
        
       			patch,

     
···

       1165
       1206
        
       		}

     

       1166
       1207
        
       	}

     

       1167
       1208
        
       

     

       1209
       1209
       +
       	mentions, references := s.mentionsResolver.Resolve(r.Context(), body)

     

       1210
       1210
       +
       

     

       1168
       1211
        
       	rkey := tid.TID()

     

       1169
       1212
        
       	initialSubmission := models.PullSubmission{

     

       1170
       1213
        
       		Patch:     patch,

     
···

       1176
       1219
        
       		Body:         body,

     

       1177
       1220
        
       		TargetBranch: targetBranch,

     

       1178
       1221
        
       		OwnerDid:     user.Did,

     

       1179
       1179
       -
       		RepoAt:       f.RepoAt(),

     

       1222
       1222
       +
       		RepoAt:       repo.RepoAt(),

     

       1180
       1223
        
       		Rkey:         rkey,

     

       1224
       1224
       +
       		Mentions:     mentions,

     

       1225
       1225
       +
       		References:   references,

     

       1181
       1226
        
       		Submissions: []*models.PullSubmission{

     

       1182
       1227
        
       			&initialSubmission,

     

       1183
       1228
        
       		},

     
···

       1189
       1234
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1190
       1235
        
       		return

     

       1191
       1236
        
       	}

     

       1192
       1192
       -
       	pullId, err := db.NextPullId(tx, f.RepoAt())

     

       1237
       1237
       +
       	pullId, err := db.NextPullId(tx, repo.RepoAt())

     

       1193
       1238
        
       	if err != nil {

     

       1194
       1239
        
       		log.Println("failed to get pull id", err)

     

       1195
       1240
        
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     
···

       1204
       1249
        
       			Val: &tangled.RepoPull{

     

       1205
       1250
        
       				Title: title,

     

       1206
       1251
        
       				Target: &tangled.RepoPull_Target{

     

       1207
       1207
       -
       					Repo:   string(f.RepoAt()),

     

       1252
       1252
       +
       					Repo:   string(repo.RepoAt()),

     

       1208
       1253
        
       					Branch: targetBranch,

     

       1209
       1254
        
       				},

     

       1210
       1255
        
       				Patch:     patch,

     
···

       1227
       1272
        
       

     

       1228
       1273
        
       	s.notifier.NewPull(r.Context(), pull)

     

       1229
       1274
        
       

     

       1230
       1230
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))

     

       1275
       1275
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1276
       1276
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))

     

       1231
       1277
        
       }

     

       1232
       1278
        
       

     

       1233
       1279
        
       func (s *Pulls) createStackedPullRequest(

     

       1234
       1280
        
       	w http.ResponseWriter,

     

       1235
       1281
        
       	r *http.Request,

     

       1236
       1236
       -
       	f *reporesolver.ResolvedRepo,

     

       1282
       1282
       +
       	repo *models.Repo,

     

       1237
       1283
        
       	user *oauth.User,

     

       1238
       1284
        
       	targetBranch string,

     

       1239
       1285
        
       	patch string,

     
···

       1265
       1311
        
       

     

       1266
       1312
        
       	// build a stack out of this patch

     

       1267
       1313
        
       	stackId := uuid.New()

     

       1268
       1268
       -
       	stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String())

     

       1314
       1314
       +
       	stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())

     

       1269
       1315
        
       	if err != nil {

     

       1270
       1316
        
       		log.Println("failed to create stack", err)

     

       1271
       1317
        
       		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))

     
···

       1328
       1374
        
       		return

     

       1329
       1375
        
       	}

     

       1330
       1376
        
       

     

       1331
       1331
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", f.OwnerSlashRepo()))

     

       1377
       1377
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1378
       1378
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))

     

       1332
       1379
        
       }

     

       1333
       1380
        
       

     

       1334
       1381
        
       func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {

     
···

       1359
       1406
        
       

     

       1360
       1407
        
       func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {

     

       1361
       1408
        
       	user := s.oauth.GetUser(r)

     

       1362
       1362
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1363
       1363
       -
       	if err != nil {

     

       1364
       1364
       -
       		log.Println("failed to get repo and knot", err)

     

       1365
       1365
       -
       		return

     

       1366
       1366
       -
       	}

     

       1367
       1409
        
       

     

       1368
       1410
        
       	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{

     

       1369
       1369
       -
       		RepoInfo: f.RepoInfo(user),

     

       1411
       1411
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1370
       1412
        
       	})

     

       1371
       1413
        
       }

     

       1372
       1414
        
       

     
···

       1387
       1429
        
       		Host: host,

     

       1388
       1430
        
       	}

     

       1389
       1431
        
       

     

       1390
       1390
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1432
       1432
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1391
       1433
        
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       1392
       1434
        
       	if err != nil {

     

       1393
       1435
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1420
       1462
        
       	}

     

       1421
       1463
        
       

     

       1422
       1464
        
       	s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{

     

       1423
       1423
       -
       		RepoInfo: f.RepoInfo(user),

     

       1465
       1465
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1424
       1466
        
       		Branches: withoutDefault,

     

       1425
       1467
        
       	})

     

       1426
       1468
        
       }

     

       1427
       1469
        
       

     

       1428
       1470
        
       func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {

     

       1429
       1471
        
       	user := s.oauth.GetUser(r)

     

       1430
       1430
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1431
       1431
       -
       	if err != nil {

     

       1432
       1432
       -
       		log.Println("failed to get repo and knot", err)

     

       1433
       1433
       -
       		return

     

       1434
       1434
       -
       	}

     

       1435
       1472
        
       

     

       1436
       1473
        
       	forks, err := db.GetForksByDid(s.db, user.Did)

     

       1437
       1474
        
       	if err != nil {

     
···

       1440
       1477
        
       	}

     

       1441
       1478
        
       

     

       1442
       1479
        
       	s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{

     

       1443
       1443
       -
       		RepoInfo: f.RepoInfo(user),

     

       1480
       1480
       +
       		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1444
       1481
        
       		Forks:    forks,

     

       1445
       1482
        
       		Selected: r.URL.Query().Get("fork"),

     

       1446
       1483
        
       	})

     
···

       1462
       1499
        
       	// fork repo

     

       1463
       1500
        
       	repo, err := db.GetRepo(

     

       1464
       1501
        
       		s.db,

     

       1465
       1465
       -
       		db.FilterEq("did", forkOwnerDid),

     

       1466
       1466
       -
       		db.FilterEq("name", forkName),

     

       1502
       1502
       +
       		orm.FilterEq("did", forkOwnerDid),

     

       1503
       1503
       +
       		orm.FilterEq("name", forkName),

     

       1467
       1504
        
       	)

     

       1468
       1505
        
       	if err != nil {

     

       1469
       1506
        
       		log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)

     
···

       1508
       1545
        
       		Host: targetHost,

     

       1509
       1546
        
       	}

     

       1510
       1547
        
       

     

       1511
       1511
       -
       	targetRepo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1548
       1548
       +
       	targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1512
       1549
        
       	targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)

     

       1513
       1550
        
       	if err != nil {

     

       1514
       1551
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1533
       1570
        
       	})

     

       1534
       1571
        
       

     

       1535
       1572
        
       	s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{

     

       1536
       1536
       -
       		RepoInfo:       f.RepoInfo(user),

     

       1573
       1573
       +
       		RepoInfo:       s.repoResolver.GetRepoInfo(r, user),

     

       1537
       1574
        
       		SourceBranches: sourceBranches.Branches,

     

       1538
       1575
        
       		TargetBranches: targetBranches.Branches,

     

       1539
       1576
        
       	})

     
···

       1541
       1578
        
       

     

       1542
       1579
        
       func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {

     

       1543
       1580
        
       	user := s.oauth.GetUser(r)

     

       1544
       1544
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1545
       1545
       -
       	if err != nil {

     

       1546
       1546
       -
       		log.Println("failed to get repo and knot", err)

     

       1547
       1547
       -
       		return

     

       1548
       1548
       -
       	}

     

       1549
       1581
        
       

     

       1550
       1582
        
       	pull, ok := r.Context().Value("pull").(*models.Pull)

     

       1551
       1583
        
       	if !ok {

     
···

       1557
       1589
        
       	switch r.Method {

     

       1558
       1590
        
       	case http.MethodGet:

     

       1559
       1591
        
       		s.pages.PullResubmitFragment(w, pages.PullResubmitParams{

     

       1560
       1560
       -
       			RepoInfo: f.RepoInfo(user),

     

       1592
       1592
       +
       			RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       1561
       1593
        
       			Pull:     pull,

     

       1562
       1594
        
       		})

     

       1563
       1595
        
       		return

     
···

       1624
       1656
        
       		return

     

       1625
       1657
        
       	}

     

       1626
       1658
        
       

     

       1627
       1627
       -
       	if !f.RepoInfo(user).Roles.IsPushAllowed() {

     

       1659
       1659
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       1660
       1660
       +
       	if !roles.IsPushAllowed() {

     

       1628
       1661
        
       		log.Println("unauthorized user")

     

       1629
       1662
        
       		w.WriteHeader(http.StatusUnauthorized)

     

       1630
       1663
        
       		return

     
···

       1639
       1672
        
       		Host: host,

     

       1640
       1673
        
       	}

     

       1641
       1674
        
       

     

       1642
       1642
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1675
       1675
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       1643
       1676
        
       	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)

     

       1644
       1677
        
       	if err != nil {

     

       1645
       1678
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     
···

       1766
       1799
        
       func (s *Pulls) resubmitPullHelper(

     

       1767
       1800
        
       	w http.ResponseWriter,

     

       1768
       1801
        
       	r *http.Request,

     

       1769
       1769
       -
       	f *reporesolver.ResolvedRepo,

     

       1802
       1802
       +
       	repo *models.Repo,

     

       1770
       1803
        
       	user *oauth.User,

     

       1771
       1804
        
       	pull *models.Pull,

     

       1772
       1805
        
       	patch string,

     
···

       1775
       1808
        
       ) {

     

       1776
       1809
        
       	if pull.IsStacked() {

     

       1777
       1810
        
       		log.Println("resubmitting stacked PR")

     

       1778
       1778
       -
       		s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId)

     

       1811
       1811
       +
       		s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)

     

       1779
       1812
        
       		return

     

       1780
       1813
        
       	}

     

       1781
       1814
        
       

     
···

       1805
       1838
        
       	}

     

       1806
       1839
        
       	defer tx.Rollback()

     

       1807
       1840
        
       

     

       1808
       1808
       -
       	pullAt := pull.PullAt()

     

       1841
       1841
       +
       	pullAt := pull.AtUri()

     

       1809
       1842
        
       	newRoundNumber := len(pull.Submissions)

     

       1810
       1843
        
       	newPatch := patch

     

       1811
       1844
        
       	newSourceRev := sourceRev

     
···

       1855
       1888
        
       			Val: &tangled.RepoPull{

     

       1856
       1889
        
       				Title: pull.Title,

     

       1857
       1890
        
       				Target: &tangled.RepoPull_Target{

     

       1858
       1858
       -
       					Repo:   string(f.RepoAt()),

     

       1891
       1891
       +
       					Repo:   string(repo.RepoAt()),

     

       1859
       1892
        
       					Branch: pull.TargetBranch,

     

       1860
       1893
        
       				},

     

       1861
       1894
        
       				Patch:     patch, // new patch

     
···

       1876
       1909
        
       		return

     

       1877
       1910
        
       	}

     

       1878
       1911
        
       

     

       1879
       1879
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       1912
       1912
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       1913
       1913
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       1880
       1914
        
       }

     

       1881
       1915
        
       

     

       1882
       1916
        
       func (s *Pulls) resubmitStackedPullHelper(

     

       1883
       1917
        
       	w http.ResponseWriter,

     

       1884
       1918
        
       	r *http.Request,

     

       1885
       1885
       -
       	f *reporesolver.ResolvedRepo,

     

       1919
       1919
       +
       	repo *models.Repo,

     

       1886
       1920
        
       	user *oauth.User,

     

       1887
       1921
        
       	pull *models.Pull,

     

       1888
       1922
        
       	patch string,

     
···

       1891
       1925
        
       	targetBranch := pull.TargetBranch

     

       1892
       1926
        
       

     

       1893
       1927
        
       	origStack, _ := r.Context().Value("stack").(models.Stack)

     

       1894
       1894
       -
       	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1928
       1928
       +
       	newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)

     

       1895
       1929
        
       	if err != nil {

     

       1896
       1930
        
       		log.Println("failed to create resubmitted stack", err)

     

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

     
···

       2002
       2036
        
       		}

     

       2003
       2037
        
       

     

       2004
       2038
        
       		// resubmit the new pull

     

       2005
       2005
       -
       		pullAt := op.PullAt()

     

       2039
       2039
       +
       		pullAt := op.AtUri()

     

       2006
       2040
        
       		newRoundNumber := len(op.Submissions)

     

       2007
       2041
        
       		newPatch := np.LatestPatch()

     

       2008
       2042
        
       		combinedPatch := np.LatestSubmission().Combined

     
···

       2033
       2067
        
       			tx,

     

       2034
       2068
        
       			p.ParentChangeId,

     

       2035
       2069
        
       			// these should be enough filters to be unique per-stack

     

       2036
       2036
       -
       			db.FilterEq("repo_at", p.RepoAt.String()),

     

       2037
       2037
       -
       			db.FilterEq("owner_did", p.OwnerDid),

     

       2038
       2038
       -
       			db.FilterEq("change_id", p.ChangeId),

     

       2070
       2070
       +
       			orm.FilterEq("repo_at", p.RepoAt.String()),

     

       2071
       2071
       +
       			orm.FilterEq("owner_did", p.OwnerDid),

     

       2072
       2072
       +
       			orm.FilterEq("change_id", p.ChangeId),

     

       2039
       2073
        
       		)

     

       2040
       2074
        
       

     

       2041
       2075
        
       		if err != nil {

     
···

       2069
       2103
        
       		return

     

       2070
       2104
        
       	}

     

       2071
       2105
        
       

     

       2072
       2072
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2106
       2106
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       2107
       2107
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2073
       2108
        
       }

     

       2074
       2109
        
       

     

       2075
       2110
        
       func (s *Pulls) MergePull(w http.ResponseWriter, r *http.Request) {

     

       2111
       2111
       +
       	user := s.oauth.GetUser(r)

     

       2076
       2112
        
       	f, err := s.repoResolver.Resolve(r)

     

       2077
       2113
        
       	if err != nil {

     

       2078
       2114
        
       		log.Println("failed to resolve repo:", err)

     
···

       2121
       2157
        
       

     

       2122
       2158
        
       	authorName := ident.Handle.String()

     

       2123
       2159
        
       	mergeInput := &tangled.RepoMerge_Input{

     

       2124
       2124
       -
       		Did:           f.OwnerDid(),

     

       2160
       2160
       +
       		Did:           f.Did,

     

       2125
       2161
        
       		Name:          f.Name,

     

       2126
       2162
        
       		Branch:        pull.TargetBranch,

     

       2127
       2163
        
       		Patch:         patch,

     
···

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

     

       2171
       2207
        
       			return

     

       2172
       2208
        
       		}

     

       2209
       2209
       +
       		p.State = models.PullMerged

     

       2173
       2210
        
       	}

     

       2174
       2211
        
       

     

       2175
       2212
        
       	err = tx.Commit()

     
···

       2182
       2219
        
       

     

       2183
       2220
        
       	// notify about the pull merge

     

       2184
       2221
        
       	for _, p := range pullsToMerge {

     

       2185
       2185
       -
       		s.notifier.NewPullMerged(r.Context(), p)

     

       2222
       2222
       +
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2186
       2223
        
       	}

     

       2187
       2224
        
       

     

       2188
       2188
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))

     

       2225
       2225
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2226
       2226
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2189
       2227
        
       }

     

       2190
       2228
        
       

     

       2191
       2229
        
       func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {

     
···

       2205
       2243
        
       	}

     

       2206
       2244
        
       

     

       2207
       2245
        
       	// auth filter: only owner or collaborators can close

     

       2208
       2208
       -
       	roles := f.RolesInRepo(user)

     

       2246
       2246
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       2209
       2247
        
       	isOwner := roles.IsOwner()

     

       2210
       2248
        
       	isCollaborator := roles.IsCollaborator()

     

       2211
       2249
        
       	isPullAuthor := user.Did == pull.OwnerDid

     
···

       2243
       2281
        
       			s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       2244
       2282
        
       			return

     

       2245
       2283
        
       		}

     

       2284
       2284
       +
       		p.State = models.PullClosed

     

       2246
       2285
        
       	}

     

       2247
       2286
        
       

     

       2248
       2287
        
       	// Commit the transaction

     
···

       2253
       2292
        
       	}

     

       2254
       2293
        
       

     

       2255
       2294
        
       	for _, p := range pullsToClose {

     

       2256
       2256
       -
       		s.notifier.NewPullClosed(r.Context(), p)

     

       2295
       2295
       +
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2257
       2296
        
       	}

     

       2258
       2297
        
       

     

       2259
       2259
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2298
       2298
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2299
       2299
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2260
       2300
        
       }

     

       2261
       2301
        
       

     

       2262
       2302
        
       func (s *Pulls) ReopenPull(w http.ResponseWriter, r *http.Request) {

     
···

       2277
       2317
        
       	}

     

       2278
       2318
        
       

     

       2279
       2319
        
       	// auth filter: only owner or collaborators can close

     

       2280
       2280
       -
       	roles := f.RolesInRepo(user)

     

       2320
       2320
       +
       	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())}

     

       2281
       2321
        
       	isOwner := roles.IsOwner()

     

       2282
       2322
        
       	isCollaborator := roles.IsCollaborator()

     

       2283
       2323
        
       	isPullAuthor := user.Did == pull.OwnerDid

     
···

       2315
       2355
        
       			s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       2316
       2356
        
       			return

     

       2317
       2357
        
       		}

     

       2358
       2358
       +
       		p.State = models.PullOpen

     

       2318
       2359
        
       	}

     

       2319
       2360
        
       

     

       2320
       2361
        
       	// Commit the transaction

     
···

       2324
       2365
        
       		return

     

       2325
       2366
        
       	}

     

       2326
       2367
        
       

     

       2327
       2327
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2368
       2368
       +
       	for _, p := range pullsToReopen {

     

       2369
       2369
       +
       		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)

     

       2370
       2370
       +
       	}

     

       2371
       2371
       +
       

     

       2372
       2372
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       2373
       2373
       +
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       2328
       2374
        
       }

     

       2329
       2375
        
       

     

       2330
       2330
       -
       func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2376
       2376
       +
       func (s *Pulls) newStack(ctx context.Context, repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2331
       2377
        
       	formatPatches, err := patchutil.ExtractPatches(patch)

     

       2332
       2378
        
       	if err != nil {

     

       2333
       2379
        
       		return nil, fmt.Errorf("Failed to extract patches: %v", err)

     
···

       2352
       2398
        
       		body := fp.Body

     

       2353
       2399
        
       		rkey := tid.TID()

     

       2354
       2400
        
       

     

       2401
       2401
       +
       		mentions, references := s.mentionsResolver.Resolve(ctx, body)

     

       2402
       2402
       +
       

     

       2355
       2403
        
       		initialSubmission := models.PullSubmission{

     

       2356
       2404
        
       			Patch:     fp.Raw,

     

       2357
       2405
        
       			SourceRev: fp.SHA,

     
···

       2362
       2410
        
       			Body:         body,

     

       2363
       2411
        
       			TargetBranch: targetBranch,

     

       2364
       2412
        
       			OwnerDid:     user.Did,

     

       2365
       2365
       -
       			RepoAt:       f.RepoAt(),

     

       2413
       2413
       +
       			RepoAt:       repo.RepoAt(),

     

       2366
       2414
        
       			Rkey:         rkey,

     

       2415
       2415
       +
       			Mentions:     mentions,

     

       2416
       2416
       +
       			References:   references,

     

       2367
       2417
        
       			Submissions: []*models.PullSubmission{

     

       2368
       2418
        
       				&initialSubmission,

     

       2369
       2419
        
       			},

+49

appview/repo/archive.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       

     

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

     

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

     

       11
       11
       +
       

     

       12
       12
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

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

     

       14
       14
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {

     

       18
       18
       +
       	l := rp.logger.With("handler", "DownloadArchive")

     

       19
       19
       +
       	ref := chi.URLParam(r, "ref")

     

       20
       20
       +
       	ref, _ = url.PathUnescape(ref)

     

       21
       21
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       22
       22
       +
       	if err != nil {

     

       23
       23
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       24
       24
       +
       		return

     

       25
       25
       +
       	}

     

       26
       26
       +
       	scheme := "http"

     

       27
       27
       +
       	if !rp.config.Core.Dev {

     

       28
       28
       +
       		scheme = "https"

     

       29
       29
       +
       	}

     

       30
       30
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       31
       31
       +
       	xrpcc := &indigoxrpc.Client{

     

       32
       32
       +
       		Host: host,

     

       33
       33
       +
       	}

     

       34
       34
       +
       	didSlashRepo := f.DidSlashRepo()

     

       35
       35
       +
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, didSlashRepo)

     

       36
       36
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       37
       37
       +
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       38
       38
       +
       		rp.pages.Error503(w)

     

       39
       39
       +
       		return

     

       40
       40
       +
       	}

     

       41
       41
       +
       	// Set headers for file download, just pass along whatever the knot specifies

     

       42
       42
       +
       	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")

     

       43
       43
       +
       	filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, safeRefFilename)

     

       44
       44
       +
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))

     

       45
       45
       +
       	w.Header().Set("Content-Type", "application/gzip")

     

       46
       46
       +
       	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes)))

     

       47
       47
       +
       	// Write the archive data directly

     

       48
       48
       +
       	w.Write(archiveBytes)

     

       49
       49
       +
       }

+21 -14

appview/repo/artifact.go

···

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

     

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

     

       16
       16
        
       	"tangled.org/core/appview/pages"

     

       17
       17
       -
       	"tangled.org/core/appview/reporesolver"

     

       18
       17
        
       	"tangled.org/core/appview/xrpcclient"

     

       18
       18
       +
       	"tangled.org/core/orm"

     

       19
       19
        
       	"tangled.org/core/tid"

     

       20
       20
        
       	"tangled.org/core/types"

     

       21
       21
        
       

     
···

       131
       131
        
       

     

       132
       132
        
       	rp.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{

     

       133
       133
        
       		LoggedInUser: user,

     

       134
       134
       -
       		RepoInfo:     f.RepoInfo(user),

     

       134
       134
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       135
       135
        
       		Artifact:     artifact,

     

       136
       136
        
       	})

     

       137
       137
        
       }

     
···

       156
       156
        
       

     

       157
       157
        
       	artifacts, err := db.GetArtifact(

     

       158
       158
        
       		rp.db,

     

       159
       159
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       160
       160
       -
       		db.FilterEq("tag", tag.Tag.Hash[:]),

     

       161
       161
       -
       		db.FilterEq("name", filename),

     

       159
       159
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       160
       160
       +
       		orm.FilterEq("tag", tag.Tag.Hash[:]),

     

       161
       161
       +
       		orm.FilterEq("name", filename),

     

       162
       162
        
       	)

     

       163
       163
        
       	if err != nil {

     

       164
       164
        
       		log.Println("failed to get artifacts", err)

     
···

       174
       174
        
       

     

       175
       175
        
       	artifact := artifacts[0]

     

       176
       176
        
       

     

       177
       177
       -
       	ownerPds := f.OwnerId.PDSEndpoint()

     

       177
       177
       +
       	ownerId, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)

     

       178
       178
       +
       	if err != nil {

     

       179
       179
       +
       		log.Println("failed to resolve repo owner did", f.Did, err)

     

       180
       180
       +
       		http.Error(w, "repository owner not found", http.StatusNotFound)

     

       181
       181
       +
       		return

     

       182
       182
       +
       	}

     

       183
       183
       +
       

     

       184
       184
       +
       	ownerPds := ownerId.PDSEndpoint()

     

       178
       185
        
       	url, _ := url.Parse(fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob", ownerPds))

     

       179
       186
        
       	q := url.Query()

     

       180
       187
        
       	q.Set("cid", artifact.BlobCid.String())

     
···

       228
       235
        
       

     

       229
       236
        
       	artifacts, err := db.GetArtifact(

     

       230
       237
        
       		rp.db,

     

       231
       231
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       232
       232
       -
       		db.FilterEq("tag", tag[:]),

     

       233
       233
       -
       		db.FilterEq("name", filename),

     

       238
       238
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       239
       239
       +
       		orm.FilterEq("tag", tag[:]),

     

       240
       240
       +
       		orm.FilterEq("name", filename),

     

       234
       241
        
       	)

     

       235
       242
        
       	if err != nil {

     

       236
       243
        
       		log.Println("failed to get artifacts", err)

     
···

       270
       277
        
       	defer tx.Rollback()

     

       271
       278
        
       

     

       272
       279
        
       	err = db.DeleteArtifact(tx,

     

       273
       273
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       274
       274
       -
       		db.FilterEq("tag", artifact.Tag[:]),

     

       275
       275
       -
       		db.FilterEq("name", filename),

     

       280
       280
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       281
       281
       +
       		orm.FilterEq("tag", artifact.Tag[:]),

     

       282
       282
       +
       		orm.FilterEq("name", filename),

     

       276
       283
        
       	)

     

       277
       284
        
       	if err != nil {

     

       278
       285
        
       		log.Println("failed to remove artifact record from db", err)

     
···

       290
       297
        
       	w.Write([]byte{})

     

       291
       298
        
       }

     

       292
       299
        
       

     

       293
       293
       -
       func (rp *Repo) resolveTag(ctx context.Context, f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) {

     

       300
       300
       +
       func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) {

     

       294
       301
        
       	tagParam, err := url.QueryUnescape(tagParam)

     

       295
       302
        
       	if err != nil {

     

       296
       303
        
       		return nil, err

     
···

       305
       312
        
       		Host: host,

     

       306
       313
        
       	}

     

       307
       314
        
       

     

       308
       308
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       315
       315
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       309
       316
        
       	xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)

     

       310
       317
        
       	if err != nil {

     

       311
       318
        
       		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

+293

appview/repo/blob.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/base64"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"io"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"net/url"

     

       9
       9
       +
       	"path/filepath"

     

       10
       10
       +
       	"slices"

     

       11
       11
       +
       	"strings"

     

       12
       12
       +
       

     

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

     

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

     

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

     

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

     

       17
       17
       +
       	"tangled.org/core/appview/pages/markup"

     

       18
       18
       +
       	"tangled.org/core/appview/reporesolver"

     

       19
       19
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       20
       20
       +
       

     

       21
       21
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

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

     

       23
       23
       +
       )

     

       24
       24
       +
       

     

       25
       25
       +
       // the content can be one of the following:

     

       26
       26
       +
       //

     

       27
       27
       +
       // - code      : text |          | raw

     

       28
       28
       +
       // - markup    : text | rendered | raw

     

       29
       29
       +
       // - svg       : text | rendered | raw

     

       30
       30
       +
       // - png       :      | rendered | raw

     

       31
       31
       +
       // - video     :      | rendered | raw

     

       32
       32
       +
       // - submodule :      | rendered |

     

       33
       33
       +
       // - rest      :      |          |

     

       34
       34
       +
       func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {

     

       35
       35
       +
       	l := rp.logger.With("handler", "RepoBlob")

     

       36
       36
       +
       

     

       37
       37
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       38
       38
       +
       	if err != nil {

     

       39
       39
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	ref := chi.URLParam(r, "ref")

     

       44
       44
       +
       	ref, _ = url.PathUnescape(ref)

     

       45
       45
       +
       

     

       46
       46
       +
       	filePath := chi.URLParam(r, "*")

     

       47
       47
       +
       	filePath, _ = url.PathUnescape(filePath)

     

       48
       48
       +
       

     

       49
       49
       +
       	scheme := "http"

     

       50
       50
       +
       	if !rp.config.Core.Dev {

     

       51
       51
       +
       		scheme = "https"

     

       52
       52
       +
       	}

     

       53
       53
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       54
       54
       +
       	xrpcc := &indigoxrpc.Client{

     

       55
       55
       +
       		Host: host,

     

       56
       56
       +
       	}

     

       57
       57
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       58
       58
       +
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       59
       59
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       60
       60
       +
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       61
       61
       +
       		rp.pages.Error503(w)

     

       62
       62
       +
       		return

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       66
       66
       +
       

     

       67
       67
       +
       	// Use XRPC response directly instead of converting to internal types

     

       68
       68
       +
       	var breadcrumbs [][]string

     

       69
       69
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})

     

       70
       70
       +
       	if filePath != "" {

     

       71
       71
       +
       		for idx, elem := range strings.Split(filePath, "/") {

     

       72
       72
       +
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       73
       73
       +
       		}

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	// Create the blob view

     

       77
       77
       +
       	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       78
       78
       +
       

     

       79
       79
       +
       	user := rp.oauth.GetUser(r)

     

       80
       80
       +
       

     

       81
       81
       +
       	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       82
       82
       +
       		LoggedInUser:    user,

     

       83
       83
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       84
       84
       +
       		BreadCrumbs:     breadcrumbs,

     

       85
       85
       +
       		BlobView:        blobView,

     

       86
       86
       +
       		RepoBlob_Output: resp,

     

       87
       87
       +
       	})

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       91
       91
       +
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       92
       92
       +
       

     

       93
       93
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       94
       94
       +
       	if err != nil {

     

       95
       95
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       96
       96
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       97
       97
       +
       		return

     

       98
       98
       +
       	}

     

       99
       99
       +
       

     

       100
       100
       +
       	ref := chi.URLParam(r, "ref")

     

       101
       101
       +
       	ref, _ = url.PathUnescape(ref)

     

       102
       102
       +
       

     

       103
       103
       +
       	filePath := chi.URLParam(r, "*")

     

       104
       104
       +
       	filePath, _ = url.PathUnescape(filePath)

     

       105
       105
       +
       

     

       106
       106
       +
       	scheme := "http"

     

       107
       107
       +
       	if !rp.config.Core.Dev {

     

       108
       108
       +
       		scheme = "https"

     

       109
       109
       +
       	}

     

       110
       110
       +
       	repo := f.DidSlashRepo()

     

       111
       111
       +
       	baseURL := &url.URL{

     

       112
       112
       +
       		Scheme: scheme,

     

       113
       113
       +
       		Host:   f.Knot,

     

       114
       114
       +
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       115
       115
       +
       	}

     

       116
       116
       +
       	query := baseURL.Query()

     

       117
       117
       +
       	query.Set("repo", repo)

     

       118
       118
       +
       	query.Set("ref", ref)

     

       119
       119
       +
       	query.Set("path", filePath)

     

       120
       120
       +
       	query.Set("raw", "true")

     

       121
       121
       +
       	baseURL.RawQuery = query.Encode()

     

       122
       122
       +
       	blobURL := baseURL.String()

     

       123
       123
       +
       	req, err := http.NewRequest("GET", blobURL, nil)

     

       124
       124
       +
       	if err != nil {

     

       125
       125
       +
       		l.Error("failed to create request", "err", err)

     

       126
       126
       +
       		return

     

       127
       127
       +
       	}

     

       128
       128
       +
       

     

       129
       129
       +
       	// forward the If-None-Match header

     

       130
       130
       +
       	if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {

     

       131
       131
       +
       		req.Header.Set("If-None-Match", clientETag)

     

       132
       132
       +
       	}

     

       133
       133
       +
       	client := &http.Client{}

     

       134
       134
       +
       

     

       135
       135
       +
       	resp, err := client.Do(req)

     

       136
       136
       +
       	if err != nil {

     

       137
       137
       +
       		l.Error("failed to reach knotserver", "err", err)

     

       138
       138
       +
       		rp.pages.Error503(w)

     

       139
       139
       +
       		return

     

       140
       140
       +
       	}

     

       141
       141
       +
       

     

       142
       142
       +
       	defer resp.Body.Close()

     

       143
       143
       +
       

     

       144
       144
       +
       	// forward 304 not modified

     

       145
       145
       +
       	if resp.StatusCode == http.StatusNotModified {

     

       146
       146
       +
       		w.WriteHeader(http.StatusNotModified)

     

       147
       147
       +
       		return

     

       148
       148
       +
       	}

     

       149
       149
       +
       

     

       150
       150
       +
       	if resp.StatusCode != http.StatusOK {

     

       151
       151
       +
       		l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode)

     

       152
       152
       +
       		w.WriteHeader(resp.StatusCode)

     

       153
       153
       +
       		_, _ = io.Copy(w, resp.Body)

     

       154
       154
       +
       		return

     

       155
       155
       +
       	}

     

       156
       156
       +
       

     

       157
       157
       +
       	contentType := resp.Header.Get("Content-Type")

     

       158
       158
       +
       	body, err := io.ReadAll(resp.Body)

     

       159
       159
       +
       	if err != nil {

     

       160
       160
       +
       		l.Error("error reading response body from knotserver", "err", err)

     

       161
       161
       +
       		w.WriteHeader(http.StatusInternalServerError)

     

       162
       162
       +
       		return

     

       163
       163
       +
       	}

     

       164
       164
       +
       

     

       165
       165
       +
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       166
       166
       +
       		// serve all textual content as text/plain

     

       167
       167
       +
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       168
       168
       +
       		w.Write(body)

     

       169
       169
       +
       	} else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {

     

       170
       170
       +
       		// serve images and videos with their original content type

     

       171
       171
       +
       		w.Header().Set("Content-Type", contentType)

     

       172
       172
       +
       		w.Write(body)

     

       173
       173
       +
       	} else {

     

       174
       174
       +
       		w.WriteHeader(http.StatusUnsupportedMediaType)

     

       175
       175
       +
       		w.Write([]byte("unsupported content type"))

     

       176
       176
       +
       		return

     

       177
       177
       +
       	}

     

       178
       178
       +
       }

     

       179
       179
       +
       

     

       180
       180
       +
       // NewBlobView creates a BlobView from the XRPC response

     

       181
       181
       +
       func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, repo *models.Repo, ref, filePath string, queryParams url.Values) models.BlobView {

     

       182
       182
       +
       	view := models.BlobView{

     

       183
       183
       +
       		Contents: "",

     

       184
       184
       +
       		Lines:    0,

     

       185
       185
       +
       	}

     

       186
       186
       +
       

     

       187
       187
       +
       	// Set size

     

       188
       188
       +
       	if resp.Size != nil {

     

       189
       189
       +
       		view.SizeHint = uint64(*resp.Size)

     

       190
       190
       +
       	} else if resp.Content != nil {

     

       191
       191
       +
       		view.SizeHint = uint64(len(*resp.Content))

     

       192
       192
       +
       	}

     

       193
       193
       +
       

     

       194
       194
       +
       	if resp.Submodule != nil {

     

       195
       195
       +
       		view.ContentType = models.BlobContentTypeSubmodule

     

       196
       196
       +
       		view.HasRenderedView = true

     

       197
       197
       +
       		view.ContentSrc = resp.Submodule.Url

     

       198
       198
       +
       		return view

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       201
       201
       +
       	// Determine if binary

     

       202
       202
       +
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       203
       203
       +
       		view.ContentSrc = generateBlobURL(config, repo, ref, filePath)

     

       204
       204
       +
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       205
       205
       +
       

     

       206
       206
       +
       		switch ext {

     

       207
       207
       +
       		case ".jpg", ".jpeg", ".png", ".gif", ".webp":

     

       208
       208
       +
       			view.ContentType = models.BlobContentTypeImage

     

       209
       209
       +
       			view.HasRawView = true

     

       210
       210
       +
       			view.HasRenderedView = true

     

       211
       211
       +
       			view.ShowingRendered = true

     

       212
       212
       +
       

     

       213
       213
       +
       		case ".svg":

     

       214
       214
       +
       			view.ContentType = models.BlobContentTypeSvg

     

       215
       215
       +
       			view.HasRawView = true

     

       216
       216
       +
       			view.HasTextView = true

     

       217
       217
       +
       			view.HasRenderedView = true

     

       218
       218
       +
       			view.ShowingRendered = queryParams.Get("code") != "true"

     

       219
       219
       +
       			if resp.Content != nil {

     

       220
       220
       +
       				bytes, _ := base64.StdEncoding.DecodeString(*resp.Content)

     

       221
       221
       +
       				view.Contents = string(bytes)

     

       222
       222
       +
       				view.Lines = strings.Count(view.Contents, "\n") + 1

     

       223
       223
       +
       			}

     

       224
       224
       +
       

     

       225
       225
       +
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       226
       226
       +
       			view.ContentType = models.BlobContentTypeVideo

     

       227
       227
       +
       			view.HasRawView = true

     

       228
       228
       +
       			view.HasRenderedView = true

     

       229
       229
       +
       			view.ShowingRendered = true

     

       230
       230
       +
       		}

     

       231
       231
       +
       

     

       232
       232
       +
       		return view

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	// otherwise, we are dealing with text content

     

       236
       236
       +
       	view.HasRawView = true

     

       237
       237
       +
       	view.HasTextView = true

     

       238
       238
       +
       

     

       239
       239
       +
       	if resp.Content != nil {

     

       240
       240
       +
       		view.Contents = *resp.Content

     

       241
       241
       +
       		view.Lines = strings.Count(view.Contents, "\n") + 1

     

       242
       242
       +
       	}

     

       243
       243
       +
       

     

       244
       244
       +
       	// with text, we may be dealing with markdown

     

       245
       245
       +
       	format := markup.GetFormat(resp.Path)

     

       246
       246
       +
       	if format == markup.FormatMarkdown {

     

       247
       247
       +
       		view.ContentType = models.BlobContentTypeMarkup

     

       248
       248
       +
       		view.HasRenderedView = true

     

       249
       249
       +
       		view.ShowingRendered = queryParams.Get("code") != "true"

     

       250
       250
       +
       	}

     

       251
       251
       +
       

     

       252
       252
       +
       	return view

     

       253
       253
       +
       }

     

       254
       254
       +
       

     

       255
       255
       +
       func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string {

     

       256
       256
       +
       	scheme := "http"

     

       257
       257
       +
       	if !config.Core.Dev {

     

       258
       258
       +
       		scheme = "https"

     

       259
       259
       +
       	}

     

       260
       260
       +
       

     

       261
       261
       +
       	repoName := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       262
       262
       +
       	baseURL := &url.URL{

     

       263
       263
       +
       		Scheme: scheme,

     

       264
       264
       +
       		Host:   repo.Knot,

     

       265
       265
       +
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       266
       266
       +
       	}

     

       267
       267
       +
       	query := baseURL.Query()

     

       268
       268
       +
       	query.Set("repo", repoName)

     

       269
       269
       +
       	query.Set("ref", ref)

     

       270
       270
       +
       	query.Set("path", filePath)

     

       271
       271
       +
       	query.Set("raw", "true")

     

       272
       272
       +
       	baseURL.RawQuery = query.Encode()

     

       273
       273
       +
       	blobURL := baseURL.String()

     

       274
       274
       +
       

     

       275
       275
       +
       	if !config.Core.Dev {

     

       276
       276
       +
       		return markup.GenerateCamoURL(config.Camo.Host, config.Camo.SharedSecret, blobURL)

     

       277
       277
       +
       	}

     

       278
       278
       +
       	return blobURL

     

       279
       279
       +
       }

     

       280
       280
       +
       

     

       281
       281
       +
       func isTextualMimeType(mimeType string) bool {

     

       282
       282
       +
       	textualTypes := []string{

     

       283
       283
       +
       		"application/json",

     

       284
       284
       +
       		"application/xml",

     

       285
       285
       +
       		"application/yaml",

     

       286
       286
       +
       		"application/x-yaml",

     

       287
       287
       +
       		"application/toml",

     

       288
       288
       +
       		"application/javascript",

     

       289
       289
       +
       		"application/ecmascript",

     

       290
       290
       +
       		"message/",

     

       291
       291
       +
       	}

     

       292
       292
       +
       	return slices.Contains(textualTypes, mimeType)

     

       293
       293
       +
       }

+95

appview/repo/branches.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       

     

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

     

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

     

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

     

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

     

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

     

       13
       13
       +
       

     

       14
       14
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) {

     

       18
       18
       +
       	l := rp.logger.With("handler", "RepoBranches")

     

       19
       19
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       20
       20
       +
       	if err != nil {

     

       21
       21
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       22
       22
       +
       		return

     

       23
       23
       +
       	}

     

       24
       24
       +
       	scheme := "http"

     

       25
       25
       +
       	if !rp.config.Core.Dev {

     

       26
       26
       +
       		scheme = "https"

     

       27
       27
       +
       	}

     

       28
       28
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       29
       29
       +
       	xrpcc := &indigoxrpc.Client{

     

       30
       30
       +
       		Host: host,

     

       31
       31
       +
       	}

     

       32
       32
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       33
       33
       +
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       34
       34
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       35
       35
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       36
       36
       +
       		rp.pages.Error503(w)

     

       37
       37
       +
       		return

     

       38
       38
       +
       	}

     

       39
       39
       +
       	var result types.RepoBranchesResponse

     

       40
       40
       +
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       41
       41
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       42
       42
       +
       		rp.pages.Error503(w)

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       45
       45
       +
       	sortBranches(result.Branches)

     

       46
       46
       +
       	user := rp.oauth.GetUser(r)

     

       47
       47
       +
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       48
       48
       +
       		LoggedInUser:         user,

     

       49
       49
       +
       		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       50
       50
       +
       		RepoBranchesResponse: result,

     

       51
       51
       +
       	})

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       func (rp *Repo) DeleteBranch(w http.ResponseWriter, r *http.Request) {

     

       55
       55
       +
       	l := rp.logger.With("handler", "DeleteBranch")

     

       56
       56
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       57
       57
       +
       	if err != nil {

     

       58
       58
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       59
       59
       +
       		return

     

       60
       60
       +
       	}

     

       61
       61
       +
       	noticeId := "delete-branch-error"

     

       62
       62
       +
       	fail := func(msg string, err error) {

     

       63
       63
       +
       		l.Error(msg, "err", err)

     

       64
       64
       +
       		rp.pages.Notice(w, noticeId, msg)

     

       65
       65
       +
       	}

     

       66
       66
       +
       	branch := r.FormValue("branch")

     

       67
       67
       +
       	if branch == "" {

     

       68
       68
       +
       		fail("No branch provided.", nil)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       	client, err := rp.oauth.ServiceClient(

     

       72
       72
       +
       		r,

     

       73
       73
       +
       		oauth.WithService(f.Knot),

     

       74
       74
       +
       		oauth.WithLxm(tangled.RepoDeleteBranchNSID),

     

       75
       75
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       76
       76
       +
       	)

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		fail("Failed to connect to knotserver", nil)

     

       79
       79
       +
       		return

     

       80
       80
       +
       	}

     

       81
       81
       +
       	err = tangled.RepoDeleteBranch(

     

       82
       82
       +
       		r.Context(),

     

       83
       83
       +
       		client,

     

       84
       84
       +
       		&tangled.RepoDeleteBranch_Input{

     

       85
       85
       +
       			Branch: branch,

     

       86
       86
       +
       			Repo:   f.RepoAt().String(),

     

       87
       87
       +
       		},

     

       88
       88
       +
       	)

     

       89
       89
       +
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       90
       90
       +
       		fail(fmt.Sprintf("Failed to delete branch: %s", err), err)

     

       91
       91
       +
       		return

     

       92
       92
       +
       	}

     

       93
       93
       +
       	l.Error("deleted branch from knot", "branch", branch, "repo", f.RepoAt())

     

       94
       94
       +
       	rp.pages.HxRefresh(w)

     

       95
       95
       +
       }

+214

appview/repo/compare.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       

     

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

     

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

     

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

     

       13
       13
       +
       	"tangled.org/core/patchutil"

     

       14
       14
       +
       	"tangled.org/core/types"

     

       15
       15
       +
       

     

       16
       16
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

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

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       func (rp *Repo) CompareNew(w http.ResponseWriter, r *http.Request) {

     

       21
       21
       +
       	l := rp.logger.With("handler", "RepoCompareNew")

     

       22
       22
       +
       

     

       23
       23
       +
       	user := rp.oauth.GetUser(r)

     

       24
       24
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       25
       25
       +
       	if err != nil {

     

       26
       26
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	scheme := "http"

     

       31
       31
       +
       	if !rp.config.Core.Dev {

     

       32
       32
       +
       		scheme = "https"

     

       33
       33
       +
       	}

     

       34
       34
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       35
       35
       +
       	xrpcc := &indigoxrpc.Client{

     

       36
       36
       +
       		Host: host,

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       40
       40
       +
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       41
       41
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       42
       42
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       43
       43
       +
       		rp.pages.Error503(w)

     

       44
       44
       +
       		return

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	var branchResult types.RepoBranchesResponse

     

       48
       48
       +
       	if err := json.Unmarshal(branchBytes, &branchResult); err != nil {

     

       49
       49
       +
       		l.Error("failed to decode XRPC branches response", "err", err)

     

       50
       50
       +
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       51
       51
       +
       		return

     

       52
       52
       +
       	}

     

       53
       53
       +
       	branches := branchResult.Branches

     

       54
       54
       +
       

     

       55
       55
       +
       	sortBranches(branches)

     

       56
       56
       +
       

     

       57
       57
       +
       	var defaultBranch string

     

       58
       58
       +
       	for _, b := range branches {

     

       59
       59
       +
       		if b.IsDefault {

     

       60
       60
       +
       			defaultBranch = b.Name

     

       61
       61
       +
       		}

     

       62
       62
       +
       	}

     

       63
       63
       +
       

     

       64
       64
       +
       	base := defaultBranch

     

       65
       65
       +
       	head := defaultBranch

     

       66
       66
       +
       

     

       67
       67
       +
       	params := r.URL.Query()

     

       68
       68
       +
       	queryBase := params.Get("base")

     

       69
       69
       +
       	queryHead := params.Get("head")

     

       70
       70
       +
       	if queryBase != "" {

     

       71
       71
       +
       		base = queryBase

     

       72
       72
       +
       	}

     

       73
       73
       +
       	if queryHead != "" {

     

       74
       74
       +
       		head = queryHead

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       78
       78
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       79
       79
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       80
       80
       +
       		rp.pages.Error503(w)

     

       81
       81
       +
       		return

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	var tags types.RepoTagsResponse

     

       85
       85
       +
       	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       86
       86
       +
       		l.Error("failed to decode XRPC tags response", "err", err)

     

       87
       87
       +
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       88
       88
       +
       		return

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       92
       92
       +
       		LoggedInUser: user,

     

       93
       93
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       94
       94
       +
       		Branches:     branches,

     

       95
       95
       +
       		Tags:         tags.Tags,

     

       96
       96
       +
       		Base:         base,

     

       97
       97
       +
       		Head:         head,

     

       98
       98
       +
       	})

     

       99
       99
       +
       }

     

       100
       100
       +
       

     

       101
       101
       +
       func (rp *Repo) Compare(w http.ResponseWriter, r *http.Request) {

     

       102
       102
       +
       	l := rp.logger.With("handler", "RepoCompare")

     

       103
       103
       +
       

     

       104
       104
       +
       	user := rp.oauth.GetUser(r)

     

       105
       105
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       106
       106
       +
       	if err != nil {

     

       107
       107
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       108
       108
       +
       		return

     

       109
       109
       +
       	}

     

       110
       110
       +
       

     

       111
       111
       +
       	var diffOpts types.DiffOpts

     

       112
       112
       +
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       113
       113
       +
       		diffOpts.Split = true

     

       114
       114
       +
       	}

     

       115
       115
       +
       

     

       116
       116
       +
       	// if user is navigating to one of

     

       117
       117
       +
       	//   /compare/{base}...{head}

     

       118
       118
       +
       	//   /compare/{base}/{head}

     

       119
       119
       +
       	var base, head string

     

       120
       120
       +
       	rest := chi.URLParam(r, "*")

     

       121
       121
       +
       

     

       122
       122
       +
       	var parts []string

     

       123
       123
       +
       	if strings.Contains(rest, "...") {

     

       124
       124
       +
       		parts = strings.SplitN(rest, "...", 2)

     

       125
       125
       +
       	} else if strings.Contains(rest, "/") {

     

       126
       126
       +
       		parts = strings.SplitN(rest, "/", 2)

     

       127
       127
       +
       	}

     

       128
       128
       +
       

     

       129
       129
       +
       	if len(parts) == 2 {

     

       130
       130
       +
       		base = parts[0]

     

       131
       131
       +
       		head = parts[1]

     

       132
       132
       +
       	}

     

       133
       133
       +
       

     

       134
       134
       +
       	base, _ = url.PathUnescape(base)

     

       135
       135
       +
       	head, _ = url.PathUnescape(head)

     

       136
       136
       +
       

     

       137
       137
       +
       	if base == "" || head == "" {

     

       138
       138
       +
       		l.Error("invalid comparison")

     

       139
       139
       +
       		rp.pages.Error404(w)

     

       140
       140
       +
       		return

     

       141
       141
       +
       	}

     

       142
       142
       +
       

     

       143
       143
       +
       	scheme := "http"

     

       144
       144
       +
       	if !rp.config.Core.Dev {

     

       145
       145
       +
       		scheme = "https"

     

       146
       146
       +
       	}

     

       147
       147
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       148
       148
       +
       	xrpcc := &indigoxrpc.Client{

     

       149
       149
       +
       		Host: host,

     

       150
       150
       +
       	}

     

       151
       151
       +
       

     

       152
       152
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       153
       153
       +
       

     

       154
       154
       +
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       155
       155
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       156
       156
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       157
       157
       +
       		rp.pages.Error503(w)

     

       158
       158
       +
       		return

     

       159
       159
       +
       	}

     

       160
       160
       +
       

     

       161
       161
       +
       	var branches types.RepoBranchesResponse

     

       162
       162
       +
       	if err := json.Unmarshal(branchBytes, &branches); err != nil {

     

       163
       163
       +
       		l.Error("failed to decode XRPC branches response", "err", err)

     

       164
       164
       +
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       165
       165
       +
       		return

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       169
       169
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       170
       170
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       171
       171
       +
       		rp.pages.Error503(w)

     

       172
       172
       +
       		return

     

       173
       173
       +
       	}

     

       174
       174
       +
       

     

       175
       175
       +
       	var tags types.RepoTagsResponse

     

       176
       176
       +
       	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       177
       177
       +
       		l.Error("failed to decode XRPC tags response", "err", err)

     

       178
       178
       +
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       179
       179
       +
       		return

     

       180
       180
       +
       	}

     

       181
       181
       +
       

     

       182
       182
       +
       	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       183
       183
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       184
       184
       +
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       185
       185
       +
       		rp.pages.Error503(w)

     

       186
       186
       +
       		return

     

       187
       187
       +
       	}

     

       188
       188
       +
       

     

       189
       189
       +
       	var formatPatch types.RepoFormatPatchResponse

     

       190
       190
       +
       	if err := json.Unmarshal(compareBytes, &formatPatch); err != nil {

     

       191
       191
       +
       		l.Error("failed to decode XRPC compare response", "err", err)

     

       192
       192
       +
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       193
       193
       +
       		return

     

       194
       194
       +
       	}

     

       195
       195
       +
       

     

       196
       196
       +
       	var diff types.NiceDiff

     

       197
       197
       +
       	if formatPatch.CombinedPatchRaw != "" {

     

       198
       198
       +
       		diff = patchutil.AsNiceDiff(formatPatch.CombinedPatchRaw, base)

     

       199
       199
       +
       	} else {

     

       200
       200
       +
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       201
       201
       +
       	}

     

       202
       202
       +
       

     

       203
       203
       +
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       204
       204
       +
       		LoggedInUser: user,

     

       205
       205
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       206
       206
       +
       		Branches:     branches.Branches,

     

       207
       207
       +
       		Tags:         tags.Tags,

     

       208
       208
       +
       		Base:         base,

     

       209
       209
       +
       		Head:         head,

     

       210
       210
       +
       		Diff:         &diff,

     

       211
       211
       +
       		DiffOpts:     diffOpts,

     

       212
       212
       +
       	})

     

       213
       213
       +
       

     

       214
       214
       +
       }

+25 -18

appview/repo/feed.go

···

       11
       11
        
       	"tangled.org/core/appview/db"

     

       12
       12
        
       	"tangled.org/core/appview/models"

     

       13
       13
        
       	"tangled.org/core/appview/pagination"

     

       14
       14
       -
       	"tangled.org/core/appview/reporesolver"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       15
       15
        
       

     

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

     

       16
       17
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       17
       18
        
       	"github.com/gorilla/feeds"

     

       18
       19
        
       )

     

       19
       20
        
       

     

       20
       20
       -
       func (rp *Repo) getRepoFeed(ctx context.Context, f *reporesolver.ResolvedRepo) (*feeds.Feed, error) {

     

       21
       21
       +
       func (rp *Repo) getRepoFeed(ctx context.Context, repo *models.Repo, ownerSlashRepo string) (*feeds.Feed, error) {

     

       21
       22
        
       	const feedLimitPerType = 100

     

       22
       23
        
       

     

       23
       23
       -
       	pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt()))

     

       24
       24
       +
       	pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, orm.FilterEq("repo_at", repo.RepoAt()))

     

       24
       25
        
       	if err != nil {

     

       25
       26
        
       		return nil, err

     

       26
       27
        
       	}

     
···

       28
       29
        
       	issues, err := db.GetIssuesPaginated(

     

       29
       30
        
       		rp.db,

     

       30
       31
        
       		pagination.Page{Limit: feedLimitPerType},

     

       31
       31
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       32
       32
       +
       		orm.FilterEq("repo_at", repo.RepoAt()),

     

       32
       33
        
       	)

     

       33
       34
        
       	if err != nil {

     

       34
       35
        
       		return nil, err

     

       35
       36
        
       	}

     

       36
       37
        
       

     

       37
       38
        
       	feed := &feeds.Feed{

     

       38
       38
       -
       		Title:   fmt.Sprintf("activity feed for %s", f.OwnerSlashRepo()),

     

       39
       39
       -
       		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, f.OwnerSlashRepo()), Type: "text/html", Rel: "alternate"},

     

       39
       39
       +
       		Title:   fmt.Sprintf("activity feed for @%s", ownerSlashRepo),

     

       40
       40
       +
       		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, ownerSlashRepo), Type: "text/html", Rel: "alternate"},

     

       40
       41
        
       		Items:   make([]*feeds.Item, 0),

     

       41
       42
        
       		Updated: time.UnixMilli(0),

     

       42
       43
        
       	}

     

       43
       44
        
       

     

       44
       45
        
       	for _, pull := range pulls {

     

       45
       45
       -
       		items, err := rp.createPullItems(ctx, pull, f)

     

       46
       46
       +
       		items, err := rp.createPullItems(ctx, pull, repo, ownerSlashRepo)

     

       46
       47
        
       		if err != nil {

     

       47
       48
        
       			return nil, err

     

       48
       49
        
       		}

     
···

       50
       51
        
       	}

     

       51
       52
        
       

     

       52
       53
        
       	for _, issue := range issues {

     

       53
       53
       -
       		item, err := rp.createIssueItem(ctx, issue, f)

     

       54
       54
       +
       		item, err := rp.createIssueItem(ctx, issue, repo, ownerSlashRepo)

     

       54
       55
        
       		if err != nil {

     

       55
       56
        
       			return nil, err

     

       56
       57
        
       		}

     
···

       71
       72
        
       	return feed, nil

     

       72
       73
        
       }

     

       73
       74
        
       

     

       74
       74
       -
       func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) {

     

       75
       75
       +
       func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, repo *models.Repo, ownerSlashRepo string) ([]*feeds.Item, error) {

     

       75
       76
        
       	owner, err := rp.idResolver.ResolveIdent(ctx, pull.OwnerDid)

     

       76
       77
        
       	if err != nil {

     

       77
       78
        
       		return nil, err

     
···

       80
       81
        
       	var items []*feeds.Item

     

       81
       82
        
       

     

       82
       83
        
       	state := rp.getPullState(pull)

     

       83
       83
       -
       	description := rp.buildPullDescription(owner.Handle, state, pull, f.OwnerSlashRepo())

     

       84
       84
       +
       	description := rp.buildPullDescription(owner.Handle, state, pull, ownerSlashRepo)

     

       84
       85
        
       

     

       85
       86
        
       	mainItem := &feeds.Item{

     

       86
       87
        
       		Title:       fmt.Sprintf("[PR #%d] %s", pull.PullId, pull.Title),

     

       87
       88
        
       		Description: description,

     

       88
       88
       -
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId)},

     

       89
       89
       +
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId)},

     

       89
       90
        
       		Created:     pull.Created,

     

       90
       91
        
       		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       91
       92
        
       	}

     
···

       98
       99
        
       

     

       99
       100
        
       		roundItem := &feeds.Item{

     

       100
       101
        
       			Title:       fmt.Sprintf("[PR #%d] %s (round #%d)", pull.PullId, pull.Title, round.RoundNumber),

     

       101
       101
       -
       			Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in %s", owner.Handle, round.RoundNumber, pull.PullId, f.OwnerSlashRepo()),

     

       102
       102
       -
       			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId, round.RoundNumber)},

     

       102
       102
       +
       			Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in @%s", owner.Handle, round.RoundNumber, pull.PullId, ownerSlashRepo),

     

       103
       103
       +
       			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId, round.RoundNumber)},

     

       103
       104
        
       			Created:     round.Created,

     

       104
       105
        
       			Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       105
       106
        
       		}

     
···

       109
       110
        
       	return items, nil

     

       110
       111
        
       }

     

       111
       112
        
       

     

       112
       112
       -
       func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) {

     

       113
       113
       +
       func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, repo *models.Repo, ownerSlashRepo string) (*feeds.Item, error) {

     

       113
       114
        
       	owner, err := rp.idResolver.ResolveIdent(ctx, issue.Did)

     

       114
       115
        
       	if err != nil {

     

       115
       116
        
       		return nil, err

     
···

       122
       123
        
       

     

       123
       124
        
       	return &feeds.Item{

     

       124
       125
        
       		Title:       fmt.Sprintf("[Issue #%d] %s", issue.IssueId, issue.Title),

     

       125
       125
       -
       		Description: fmt.Sprintf("@%s %s issue #%d in %s", owner.Handle, state, issue.IssueId, f.OwnerSlashRepo()),

     

       126
       126
       -
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), issue.IssueId)},

     

       126
       126
       +
       		Description: fmt.Sprintf("@%s %s issue #%d in @%s", owner.Handle, state, issue.IssueId, ownerSlashRepo),

     

       127
       127
       +
       		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, ownerSlashRepo, issue.IssueId)},

     

       127
       128
        
       		Created:     issue.Created,

     

       128
       129
        
       		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},

     

       129
       130
        
       	}, nil

     
···

       146
       147
        
       	return fmt.Sprintf("%s in %s", base, repoName)

     

       147
       148
        
       }

     

       148
       149
        
       

     

       149
       149
       -
       func (rp *Repo) RepoAtomFeed(w http.ResponseWriter, r *http.Request) {

     

       150
       150
       +
       func (rp *Repo) AtomFeed(w http.ResponseWriter, r *http.Request) {

     

       150
       151
        
       	f, err := rp.repoResolver.Resolve(r)

     

       151
       152
        
       	if err != nil {

     

       152
       153
        
       		log.Println("failed to fully resolve repo:", err)

     

       153
       154
        
       		return

     

       154
       155
        
       	}

     

       156
       156
       +
       	repoOwnerId, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       157
       157
       +
       	if !ok || repoOwnerId.Handle.IsInvalidHandle() {

     

       158
       158
       +
       		log.Println("failed to get resolved repo owner id")

     

       159
       159
       +
       		return

     

       160
       160
       +
       	}

     

       161
       161
       +
       	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name

     

       155
       162
        
       

     

       156
       156
       -
       	feed, err := rp.getRepoFeed(r.Context(), f)

     

       163
       163
       +
       	feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)

     

       157
       164
        
       	if err != nil {

     

       158
       165
        
       		log.Println("failed to get repo feed:", err)

     

       159
       166
        
       		rp.pages.Error500(w)

+28 -30

appview/repo/index.go

···

       22
       22
        
       	"tangled.org/core/appview/db"

     

       23
       23
        
       	"tangled.org/core/appview/models"

     

       24
       24
        
       	"tangled.org/core/appview/pages"

     

       25
       25
       -
       	"tangled.org/core/appview/reporesolver"

     

       26
       25
        
       	"tangled.org/core/appview/xrpcclient"

     

       26
       26
       +
       	"tangled.org/core/orm"

     

       27
       27
        
       	"tangled.org/core/types"

     

       28
       28
        
       

     

       29
       29
        
       	"github.com/go-chi/chi/v5"

     

       30
       30
        
       	"github.com/go-enry/go-enry/v2"

     

       31
       31
        
       )

     

       32
       32
        
       

     

       33
       33
       -
       func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       33
       33
       +
       func (rp *Repo) Index(w http.ResponseWriter, r *http.Request) {

     

       34
       34
        
       	l := rp.logger.With("handler", "RepoIndex")

     

       35
       35
        
       

     

       36
       36
        
       	ref := chi.URLParam(r, "ref")

     
···

       52
       52
        
       	}

     

       53
       53
        
       

     

       54
       54
        
       	user := rp.oauth.GetUser(r)

     

       55
       55
       -
       	repoInfo := f.RepoInfo(user)

     

       56
       55
        
       

     

       57
       56
        
       	// Build index response from multiple XRPC calls

     

       58
       57
        
       	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     
···

       62
       61
        
       			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       63
       62
        
       				LoggedInUser:     user,

     

       64
       63
        
       				NeedsKnotUpgrade: true,

     

       65
       65
       -
       				RepoInfo:         repoInfo,

     

       64
       64
       +
       				RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       66
       65
        
       			})

     

       67
       66
        
       			return

     

       68
       67
        
       		}

     
···

       124
       123
        
       		l.Error("failed to get email to did map", "err", err)

     

       125
       124
        
       	}

     

       126
       125
        
       

     

       127
       127
       -
       	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, commitsTrunc)

     

       126
       126
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, commitsTrunc)

     

       128
       127
        
       	if err != nil {

     

       129
       128
        
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       130
       129
        
       	}

     
···

       140
       139
        
       	for _, c := range commitsTrunc {

     

       141
       140
        
       		shas = append(shas, c.Hash.String())

     

       142
       141
        
       	}

     

       143
       143
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       142
       142
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       144
       143
        
       	if err != nil {

     

       145
       144
        
       		l.Error("failed to fetch pipeline statuses", "err", err)

     

       146
       145
        
       		// non-fatal

     
···

       148
       147
        
       

     

       149
       148
        
       	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       150
       149
        
       		LoggedInUser:      user,

     

       151
       151
       -
       		RepoInfo:          repoInfo,

     

       150
       150
       +
       		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       152
       151
        
       		TagMap:            tagMap,

     

       153
       152
        
       		RepoIndexResponse: *result,

     

       154
       153
        
       		CommitsTrunc:      commitsTrunc,

     

       155
       154
        
       		TagsTrunc:         tagsTrunc,

     

       156
       155
        
       		// ForkInfo:           forkInfo, // TODO: reinstate this after xrpc properly lands

     

       157
       157
       -
       		BranchesTrunc:      branchesTrunc,

     

       158
       158
       -
       		EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),

     

       159
       159
       -
       		VerifiedCommits:    vc,

     

       160
       160
       -
       		Languages:          languageInfo,

     

       161
       161
       -
       		Pipelines:          pipelines,

     

       156
       156
       +
       		BranchesTrunc:   branchesTrunc,

     

       157
       157
       +
       		EmailToDid:      emailToDidMap,

     

       158
       158
       +
       		VerifiedCommits: vc,

     

       159
       159
       +
       		Languages:       languageInfo,

     

       160
       160
       +
       		Pipelines:       pipelines,

     

       162
       161
        
       	})

     

       163
       162
        
       }

     

       164
       163
        
       

     

       165
       164
        
       func (rp *Repo) getLanguageInfo(

     

       166
       165
        
       	ctx context.Context,

     

       167
       166
        
       	l *slog.Logger,

     

       168
       168
       -
       	f *reporesolver.ResolvedRepo,

     

       167
       167
       +
       	repo *models.Repo,

     

       169
       168
        
       	xrpcc *indigoxrpc.Client,

     

       170
       169
        
       	currentRef string,

     

       171
       170
        
       	isDefaultRef bool,

     
···

       173
       172
        
       	// first attempt to fetch from db

     

       174
       173
        
       	langs, err := db.GetRepoLanguages(

     

       175
       174
        
       		rp.db,

     

       176
       176
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       177
       177
       -
       		db.FilterEq("ref", currentRef),

     

       175
       175
       +
       		orm.FilterEq("repo_at", repo.RepoAt()),

     

       176
       176
       +
       		orm.FilterEq("ref", currentRef),

     

       178
       177
        
       	)

     

       179
       178
        
       

     

       180
       179
        
       	if err != nil || langs == nil {

     

       181
       180
        
       		// non-fatal, fetch langs from ks via XRPC

     

       182
       182
       -
       		repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       183
       183
       -
       		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)

     

       181
       181
       +
       		didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       182
       182
       +
       		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)

     

       184
       183
        
       		if err != nil {

     

       185
       184
        
       			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       186
       185
        
       				l.Error("failed to call XRPC repo.languages", "err", xrpcerr)

     
···

       195
       194
        
       

     

       196
       195
        
       		for _, lang := range ls.Languages {

     

       197
       196
        
       			langs = append(langs, models.RepoLanguage{

     

       198
       198
       -
       				RepoAt:       f.RepoAt(),

     

       197
       197
       +
       				RepoAt:       repo.RepoAt(),

     

       199
       198
        
       				Ref:          currentRef,

     

       200
       199
        
       				IsDefaultRef: isDefaultRef,

     

       201
       200
        
       				Language:     lang.Name,

     
···

       210
       209
        
       		defer tx.Rollback()

     

       211
       210
        
       

     

       212
       211
        
       		// update appview's cache

     

       213
       213
       -
       		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       212
       212
       +
       		err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)

     

       214
       213
        
       		if err != nil {

     

       215
       214
        
       			// non-fatal

     

       216
       215
        
       			l.Error("failed to cache lang results", "err", err)

     
···

       255
       254
        
       }

     

       256
       255
        
       

     

       257
       256
        
       // buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel

     

       258
       258
       -
       func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) {

     

       259
       259
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       257
       257
       +
       func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {

     

       258
       258
       +
       	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       260
       259
        
       

     

       261
       260
        
       	// first get branches to determine the ref if not specified

     

       262
       262
       -
       	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo)

     

       261
       261
       +
       	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)

     

       263
       262
        
       	if err != nil {

     

       264
       263
        
       		return nil, fmt.Errorf("failed to call repoBranches: %w", err)

     

       265
       264
        
       	}

     
···

       303
       302
        
       	wg.Add(1)

     

       304
       303
        
       	go func() {

     

       305
       304
        
       		defer wg.Done()

     

       306
       306
       -
       		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)

     

       305
       305
       +
       		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)

     

       307
       306
        
       		if err != nil {

     

       308
       307
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))

     

       309
       308
        
       			return

     
···

       318
       317
        
       	wg.Add(1)

     

       319
       318
        
       	go func() {

     

       320
       319
        
       		defer wg.Done()

     

       321
       321
       -
       		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo)

     

       320
       320
       +
       		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)

     

       322
       321
        
       		if err != nil {

     

       323
       322
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))

     

       324
       323
        
       			return

     
···

       330
       329
        
       	wg.Add(1)

     

       331
       330
        
       	go func() {

     

       332
       331
        
       		defer wg.Done()

     

       333
       333
       -
       		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo)

     

       332
       332
       +
       		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)

     

       334
       333
        
       		if err != nil {

     

       335
       334
        
       			errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))

     

       336
       335
        
       			return

     
···

       351
       350
        
       	if treeResp != nil && treeResp.Files != nil {

     

       352
       351
        
       		for _, file := range treeResp.Files {

     

       353
       352
        
       			niceFile := types.NiceTree{

     

       354
       354
       -
       				IsFile:    file.Is_file,

     

       355
       355
       -
       				IsSubtree: file.Is_subtree,

     

       356
       356
       -
       				Name:      file.Name,

     

       357
       357
       -
       				Mode:      file.Mode,

     

       358
       358
       -
       				Size:      file.Size,

     

       353
       353
       +
       				Name: file.Name,

     

       354
       354
       +
       				Mode: file.Mode,

     

       355
       355
       +
       				Size: file.Size,

     

       359
       356
        
       			}

     

       357
       357
       +
       

     

       360
       358
        
       			if file.Last_commit != nil {

     

       361
       359
        
       				when, _ := time.Parse(time.RFC3339, file.Last_commit.When)

     

       362
       360
        
       				niceFile.LastCommit = &types.LastCommitInfo{

+220

appview/repo/log.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       16
       16
       +
       	"tangled.org/core/types"

     

       17
       17
       +
       

     

       18
       18
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

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

     

       20
       20
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       21
       21
       +
       )

     

       22
       22
       +
       

     

       23
       23
       +
       func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) {

     

       24
       24
       +
       	l := rp.logger.With("handler", "RepoLog")

     

       25
       25
       +
       

     

       26
       26
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       27
       27
       +
       	if err != nil {

     

       28
       28
       +
       		l.Error("failed to fully resolve repo", "err", err)

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	page := 1

     

       33
       33
       +
       	if r.URL.Query().Get("page") != "" {

     

       34
       34
       +
       		page, err = strconv.Atoi(r.URL.Query().Get("page"))

     

       35
       35
       +
       		if err != nil {

     

       36
       36
       +
       			page = 1

     

       37
       37
       +
       		}

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	ref := chi.URLParam(r, "ref")

     

       41
       41
       +
       	ref, _ = url.PathUnescape(ref)

     

       42
       42
       +
       

     

       43
       43
       +
       	scheme := "http"

     

       44
       44
       +
       	if !rp.config.Core.Dev {

     

       45
       45
       +
       		scheme = "https"

     

       46
       46
       +
       	}

     

       47
       47
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       48
       48
       +
       	xrpcc := &indigoxrpc.Client{

     

       49
       49
       +
       		Host: host,

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	limit := int64(60)

     

       53
       53
       +
       	cursor := ""

     

       54
       54
       +
       	if page > 1 {

     

       55
       55
       +
       		// Convert page number to cursor (offset)

     

       56
       56
       +
       		offset := (page - 1) * int(limit)

     

       57
       57
       +
       		cursor = strconv.Itoa(offset)

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       61
       61
       +
       	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       62
       62
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       63
       63
       +
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       64
       64
       +
       		rp.pages.Error503(w)

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	var xrpcResp types.RepoLogResponse

     

       69
       69
       +
       	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       70
       70
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       71
       71
       +
       		rp.pages.Error503(w)

     

       72
       72
       +
       		return

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       76
       76
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       77
       77
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       78
       78
       +
       		rp.pages.Error503(w)

     

       79
       79
       +
       		return

     

       80
       80
       +
       	}

     

       81
       81
       +
       

     

       82
       82
       +
       	tagMap := make(map[string][]string)

     

       83
       83
       +
       	if tagBytes != nil {

     

       84
       84
       +
       		var tagResp types.RepoTagsResponse

     

       85
       85
       +
       		if err := json.Unmarshal(tagBytes, &tagResp); err == nil {

     

       86
       86
       +
       			for _, tag := range tagResp.Tags {

     

       87
       87
       +
       				hash := tag.Hash

     

       88
       88
       +
       				if tag.Tag != nil {

     

       89
       89
       +
       					hash = tag.Tag.Target.String()

     

       90
       90
       +
       				}

     

       91
       91
       +
       				tagMap[hash] = append(tagMap[hash], tag.Name)

     

       92
       92
       +
       			}

     

       93
       93
       +
       		}

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       97
       97
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       98
       98
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       99
       99
       +
       		rp.pages.Error503(w)

     

       100
       100
       +
       		return

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	if branchBytes != nil {

     

       104
       104
       +
       		var branchResp types.RepoBranchesResponse

     

       105
       105
       +
       		if err := json.Unmarshal(branchBytes, &branchResp); err == nil {

     

       106
       106
       +
       			for _, branch := range branchResp.Branches {

     

       107
       107
       +
       				tagMap[branch.Hash] = append(tagMap[branch.Hash], branch.Name)

     

       108
       108
       +
       			}

     

       109
       109
       +
       		}

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	user := rp.oauth.GetUser(r)

     

       113
       113
       +
       

     

       114
       114
       +
       	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       115
       115
       +
       	if err != nil {

     

       116
       116
       +
       		l.Error("failed to fetch email to did mapping", "err", err)

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, xrpcResp.Commits)

     

       120
       120
       +
       	if err != nil {

     

       121
       121
       +
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       122
       122
       +
       	}

     

       123
       123
       +
       

     

       124
       124
       +
       	var shas []string

     

       125
       125
       +
       	for _, c := range xrpcResp.Commits {

     

       126
       126
       +
       		shas = append(shas, c.Hash.String())

     

       127
       127
       +
       	}

     

       128
       128
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, shas)

     

       129
       129
       +
       	if err != nil {

     

       130
       130
       +
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       131
       131
       +
       		// non-fatal

     

       132
       132
       +
       	}

     

       133
       133
       +
       

     

       134
       134
       +
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       135
       135
       +
       		LoggedInUser:    user,

     

       136
       136
       +
       		TagMap:          tagMap,

     

       137
       137
       +
       		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       138
       138
       +
       		RepoLogResponse: xrpcResp,

     

       139
       139
       +
       		EmailToDid:      emailToDidMap,

     

       140
       140
       +
       		VerifiedCommits: vc,

     

       141
       141
       +
       		Pipelines:       pipelines,

     

       142
       142
       +
       	})

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) {

     

       146
       146
       +
       	l := rp.logger.With("handler", "RepoCommit")

     

       147
       147
       +
       

     

       148
       148
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       149
       149
       +
       	if err != nil {

     

       150
       150
       +
       		l.Error("failed to fully resolve repo", "err", err)

     

       151
       151
       +
       		return

     

       152
       152
       +
       	}

     

       153
       153
       +
       	ref := chi.URLParam(r, "ref")

     

       154
       154
       +
       	ref, _ = url.PathUnescape(ref)

     

       155
       155
       +
       

     

       156
       156
       +
       	var diffOpts types.DiffOpts

     

       157
       157
       +
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       158
       158
       +
       		diffOpts.Split = true

     

       159
       159
       +
       	}

     

       160
       160
       +
       

     

       161
       161
       +
       	if !plumbing.IsHash(ref) {

     

       162
       162
       +
       		rp.pages.Error404(w)

     

       163
       163
       +
       		return

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	scheme := "http"

     

       167
       167
       +
       	if !rp.config.Core.Dev {

     

       168
       168
       +
       		scheme = "https"

     

       169
       169
       +
       	}

     

       170
       170
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       171
       171
       +
       	xrpcc := &indigoxrpc.Client{

     

       172
       172
       +
       		Host: host,

     

       173
       173
       +
       	}

     

       174
       174
       +
       

     

       175
       175
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       176
       176
       +
       	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       177
       177
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       178
       178
       +
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       179
       179
       +
       		rp.pages.Error503(w)

     

       180
       180
       +
       		return

     

       181
       181
       +
       	}

     

       182
       182
       +
       

     

       183
       183
       +
       	var result types.RepoCommitResponse

     

       184
       184
       +
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       185
       185
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       186
       186
       +
       		rp.pages.Error503(w)

     

       187
       187
       +
       		return

     

       188
       188
       +
       	}

     

       189
       189
       +
       

     

       190
       190
       +
       	emailToDidMap, err := db.GetEmailToDid(rp.db, []string{result.Diff.Commit.Committer.Email, result.Diff.Commit.Author.Email}, true)

     

       191
       191
       +
       	if err != nil {

     

       192
       192
       +
       		l.Error("failed to get email to did mapping", "err", err)

     

       193
       193
       +
       	}

     

       194
       194
       +
       

     

       195
       195
       +
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.Commit{result.Diff.Commit})

     

       196
       196
       +
       	if err != nil {

     

       197
       197
       +
       		l.Error("failed to GetVerifiedCommits", "err", err)

     

       198
       198
       +
       	}

     

       199
       199
       +
       

     

       200
       200
       +
       	user := rp.oauth.GetUser(r)

     

       201
       201
       +
       	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})

     

       202
       202
       +
       	if err != nil {

     

       203
       203
       +
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       204
       204
       +
       		// non-fatal

     

       205
       205
       +
       	}

     

       206
       206
       +
       	var pipeline *models.Pipeline

     

       207
       207
       +
       	if p, ok := pipelines[result.Diff.Commit.This]; ok {

     

       208
       208
       +
       		pipeline = &p

     

       209
       209
       +
       	}

     

       210
       210
       +
       

     

       211
       211
       +
       	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       212
       212
       +
       		LoggedInUser:       user,

     

       213
       213
       +
       		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       214
       214
       +
       		RepoCommitResponse: result,

     

       215
       215
       +
       		EmailToDid:         emailToDidMap,

     

       216
       216
       +
       		VerifiedCommit:     vc,

     

       217
       217
       +
       		Pipeline:           pipeline,

     

       218
       218
       +
       		DiffOpts:           diffOpts,

     

       219
       219
       +
       	})

     

       220
       220
       +
       }

+9 -8

appview/repo/opengraph.go

···

       16
       16
        
       	"tangled.org/core/appview/db"

     

       17
       17
        
       	"tangled.org/core/appview/models"

     

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

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/types"

     

       20
       21
        
       )

     

       21
       22
        
       

     
···

       158
       159
        
       	// Draw star icon, count, and label

     

       159
       160
        
       	// Align icon baseline with text baseline

     

       160
       161
        
       	iconBaselineOffset := int(textSize) / 2

     

       161
       161
       -
       	err = statsArea.DrawSVGIcon("static/icons/star.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       162
       162
       +
       	err = statsArea.DrawLucideIcon("star", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       162
       163
        
       	if err != nil {

     

       163
       164
        
       		log.Printf("failed to draw star icon: %v", err)

     

       164
       165
        
       	}

     
···

       185
       186
        
       

     

       186
       187
        
       	// Draw issues icon, count, and label

     

       187
       188
        
       	issueStartX := currentX

     

       188
       188
       -
       	err = statsArea.DrawSVGIcon("static/icons/circle-dot.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       189
       189
       +
       	err = statsArea.DrawLucideIcon("circle-dot", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       189
       190
        
       	if err != nil {

     

       190
       191
        
       		log.Printf("failed to draw circle-dot icon: %v", err)

     

       191
       192
        
       	}

     
···

       210
       211
        
       

     

       211
       212
        
       	// Draw pull request icon, count, and label

     

       212
       213
        
       	prStartX := currentX

     

       213
       213
       -
       	err = statsArea.DrawSVGIcon("static/icons/git-pull-request.svg", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       214
       214
       +
       	err = statsArea.DrawLucideIcon("git-pull-request", currentX, statsY+iconBaselineOffset-iconSize/2+5, iconSize, iconColor)

     

       214
       215
        
       	if err != nil {

     

       215
       216
        
       		log.Printf("failed to draw git-pull-request icon: %v", err)

     

       216
       217
        
       	}

     
···

       236
       237
        
       	dollyX := dollyBounds.Min.X + (dollyBounds.Dx() / 2) - (dollySize / 2)

     

       237
       238
        
       	dollyY := statsY + iconBaselineOffset - dollySize/2 + 25

     

       238
       239
        
       	dollyColor := color.RGBA{180, 180, 180, 255} // light gray

     

       239
       239
       -
       	err = dollyArea.DrawSVGIcon("templates/fragments/dolly/silhouette.svg", dollyX, dollyY, dollySize, dollyColor)

     

       240
       240
       +
       	err = dollyArea.DrawDollySilhouette(dollyX, dollyY, dollySize, dollyColor)

     

       240
       241
        
       	if err != nil {

     

       241
       242
        
       		log.Printf("dolly silhouette not available (this is ok): %v", err)

     

       242
       243
        
       	}

     
···

       327
       328
        
       	return nil

     

       328
       329
        
       }

     

       329
       330
        
       

     

       330
       330
       -
       func (rp *Repo) RepoOpenGraphSummary(w http.ResponseWriter, r *http.Request) {

     

       331
       331
       +
       func (rp *Repo) Opengraph(w http.ResponseWriter, r *http.Request) {

     

       331
       332
        
       	f, err := rp.repoResolver.Resolve(r)

     

       332
       333
        
       	if err != nil {

     

       333
       334
        
       		log.Println("failed to get repo and knot", err)

     
···

       338
       339
        
       	var languageStats []types.RepoLanguageDetails

     

       339
       340
        
       	langs, err := db.GetRepoLanguages(

     

       340
       341
        
       		rp.db,

     

       341
       341
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       342
       342
       -
       		db.FilterEq("is_default_ref", 1),

     

       342
       342
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       343
       343
       +
       		orm.FilterEq("is_default_ref", 1),

     

       343
       344
        
       	)

     

       344
       345
        
       	if err != nil {

     

       345
       346
        
       		log.Printf("failed to get language stats from db: %v", err)

     
···

       374
       375
        
       		})

     

       375
       376
        
       	}

     

       376
       377
        
       

     

       377
       377
       -
       	card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)

     

       378
       378
       +
       	card, err := rp.drawRepoSummaryCard(f, languageStats)

     

       378
       379
        
       	if err != nil {

     

       379
       380
        
       		log.Println("failed to draw repo summary card", err)

     

       380
       381
        
       		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

+39 -1413

appview/repo/repo.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"database/sql"

     

       6
       6
       -
       	"encoding/json"

     

       7
       6
        
       	"errors"

     

       8
       7
        
       	"fmt"

     

       9
       9
       -
       	"io"

     

       10
       8
        
       	"log/slog"

     

       11
       9
        
       	"net/http"

     

       12
       10
        
       	"net/url"

     

       13
       13
       -
       	"path/filepath"

     

       14
       11
        
       	"slices"

     

       15
       15
       -
       	"strconv"

     

       16
       12
        
       	"strings"

     

       17
       13
        
       	"time"

     

       18
       14
        
       

     

       19
       15
        
       	"tangled.org/core/api/tangled"

     

       20
       20
       -
       	"tangled.org/core/appview/commitverify"

     

       21
       16
        
       	"tangled.org/core/appview/config"

     

       22
       17
        
       	"tangled.org/core/appview/db"

     

       23
       18
        
       	"tangled.org/core/appview/models"

     

       24
       19
        
       	"tangled.org/core/appview/notify"

     

       25
       20
        
       	"tangled.org/core/appview/oauth"

     

       26
       21
        
       	"tangled.org/core/appview/pages"

     

       27
       27
       -
       	"tangled.org/core/appview/pages/markup"

     

       28
       22
        
       	"tangled.org/core/appview/reporesolver"

     

       29
       23
        
       	"tangled.org/core/appview/validator"

     

       30
       24
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       31
       25
        
       	"tangled.org/core/eventconsumer"

     

       32
       26
        
       	"tangled.org/core/idresolver"

     

       33
       33
       -
       	"tangled.org/core/patchutil"

     

       27
       27
       +
       	"tangled.org/core/orm"

     

       34
       28
        
       	"tangled.org/core/rbac"

     

       35
       29
        
       	"tangled.org/core/tid"

     

       36
       36
       -
       	"tangled.org/core/types"

     

       37
       30
        
       	"tangled.org/core/xrpc/serviceauth"

     

       38
       31
        
       

     

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

     

       40
       33
        
       	atpclient "github.com/bluesky-social/indigo/atproto/client"

     

       41
       34
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       42
       35
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       43
       43
       -
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       44
       36
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       45
       37
        
       	"github.com/go-chi/chi/v5"

     

       46
       46
       -
       	"github.com/go-git/go-git/v5/plumbing"

     

       47
       38
        
       )

     

       48
       39
        
       

     

       49
       40
        
       type Repo struct {

     
···

       88
       79
        
       	}

     

       89
       80
        
       }

     

       90
       81
        
       

     

       91
       91
       -
       func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {

     

       92
       92
       -
       	l := rp.logger.With("handler", "DownloadArchive")

     

       93
       93
       -
       

     

       94
       94
       -
       	ref := chi.URLParam(r, "ref")

     

       95
       95
       -
       	ref, _ = url.PathUnescape(ref)

     

       96
       96
       -
       

     

       97
       97
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       98
       98
       -
       	if err != nil {

     

       99
       99
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       100
       100
       -
       		return

     

       101
       101
       -
       	}

     

       102
       102
       -
       

     

       103
       103
       -
       	scheme := "http"

     

       104
       104
       -
       	if !rp.config.Core.Dev {

     

       105
       105
       -
       		scheme = "https"

     

       106
       106
       -
       	}

     

       107
       107
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       108
       108
       -
       	xrpcc := &indigoxrpc.Client{

     

       109
       109
       -
       		Host: host,

     

       110
       110
       -
       	}

     

       111
       111
       -
       

     

       112
       112
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       113
       113
       -
       	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       114
       114
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       115
       115
       -
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       116
       116
       -
       		rp.pages.Error503(w)

     

       117
       117
       -
       		return

     

       118
       118
       -
       	}

     

       119
       119
       -
       

     

       120
       120
       -
       	// Set headers for file download, just pass along whatever the knot specifies

     

       121
       121
       -
       	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")

     

       122
       122
       -
       	filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, safeRefFilename)

     

       123
       123
       -
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))

     

       124
       124
       -
       	w.Header().Set("Content-Type", "application/gzip")

     

       125
       125
       -
       	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes)))

     

       126
       126
       -
       

     

       127
       127
       -
       	// Write the archive data directly

     

       128
       128
       -
       	w.Write(archiveBytes)

     

       129
       129
       -
       }

     

       130
       130
       -
       

     

       131
       131
       -
       func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       132
       132
       -
       	l := rp.logger.With("handler", "RepoLog")

     

       133
       133
       -
       

     

       134
       134
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       135
       135
       -
       	if err != nil {

     

       136
       136
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       137
       137
       -
       		return

     

       138
       138
       -
       	}

     

       139
       139
       -
       

     

       140
       140
       -
       	page := 1

     

       141
       141
       -
       	if r.URL.Query().Get("page") != "" {

     

       142
       142
       -
       		page, err = strconv.Atoi(r.URL.Query().Get("page"))

     

       143
       143
       -
       		if err != nil {

     

       144
       144
       -
       			page = 1

     

       145
       145
       -
       		}

     

       146
       146
       -
       	}

     

       147
       147
       -
       

     

       148
       148
       -
       	ref := chi.URLParam(r, "ref")

     

       149
       149
       -
       	ref, _ = url.PathUnescape(ref)

     

       150
       150
       -
       

     

       151
       151
       -
       	scheme := "http"

     

       152
       152
       -
       	if !rp.config.Core.Dev {

     

       153
       153
       -
       		scheme = "https"

     

       154
       154
       -
       	}

     

       155
       155
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       156
       156
       -
       	xrpcc := &indigoxrpc.Client{

     

       157
       157
       -
       		Host: host,

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       160
       -
       	limit := int64(60)

     

       161
       161
       -
       	cursor := ""

     

       162
       162
       -
       	if page > 1 {

     

       163
       163
       -
       		// Convert page number to cursor (offset)

     

       164
       164
       -
       		offset := (page - 1) * int(limit)

     

       165
       165
       -
       		cursor = strconv.Itoa(offset)

     

       166
       166
       -
       	}

     

       167
       167
       -
       

     

       168
       168
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       169
       169
       -
       	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       170
       170
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       171
       171
       -
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       172
       172
       -
       		rp.pages.Error503(w)

     

       173
       173
       -
       		return

     

       174
       174
       -
       	}

     

       175
       175
       -
       

     

       176
       176
       -
       	var xrpcResp types.RepoLogResponse

     

       177
       177
       -
       	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       178
       178
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       179
       179
       -
       		rp.pages.Error503(w)

     

       180
       180
       -
       		return

     

       181
       181
       -
       	}

     

       182
       182
       -
       

     

       183
       183
       -
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       184
       184
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       185
       185
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       186
       186
       -
       		rp.pages.Error503(w)

     

       187
       187
       -
       		return

     

       188
       188
       -
       	}

     

       189
       189
       -
       

     

       190
       190
       -
       	tagMap := make(map[string][]string)

     

       191
       191
       -
       	if tagBytes != nil {

     

       192
       192
       -
       		var tagResp types.RepoTagsResponse

     

       193
       193
       -
       		if err := json.Unmarshal(tagBytes, &tagResp); err == nil {

     

       194
       194
       -
       			for _, tag := range tagResp.Tags {

     

       195
       195
       -
       				hash := tag.Hash

     

       196
       196
       -
       				if tag.Tag != nil {

     

       197
       197
       -
       					hash = tag.Tag.Target.String()

     

       198
       198
       -
       				}

     

       199
       199
       -
       				tagMap[hash] = append(tagMap[hash], tag.Name)

     

       200
       200
       -
       			}

     

       201
       201
       -
       		}

     

       202
       202
       -
       	}

     

       203
       203
       -
       

     

       204
       204
       -
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       205
       205
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       206
       206
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       207
       207
       -
       		rp.pages.Error503(w)

     

       208
       208
       -
       		return

     

       209
       209
       -
       	}

     

       210
       210
       -
       

     

       211
       211
       -
       	if branchBytes != nil {

     

       212
       212
       -
       		var branchResp types.RepoBranchesResponse

     

       213
       213
       -
       		if err := json.Unmarshal(branchBytes, &branchResp); err == nil {

     

       214
       214
       -
       			for _, branch := range branchResp.Branches {

     

       215
       215
       -
       				tagMap[branch.Hash] = append(tagMap[branch.Hash], branch.Name)

     

       216
       216
       -
       			}

     

       217
       217
       -
       		}

     

       218
       218
       -
       	}

     

       219
       219
       -
       

     

       220
       220
       -
       	user := rp.oauth.GetUser(r)

     

       221
       221
       -
       

     

       222
       222
       -
       	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       223
       223
       -
       	if err != nil {

     

       224
       224
       -
       		l.Error("failed to fetch email to did mapping", "err", err)

     

       225
       225
       -
       	}

     

       226
       226
       -
       

     

       227
       227
       -
       	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, xrpcResp.Commits)

     

       228
       228
       -
       	if err != nil {

     

       229
       229
       -
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       230
       230
       -
       	}

     

       231
       231
       -
       

     

       232
       232
       -
       	repoInfo := f.RepoInfo(user)

     

       233
       233
       -
       

     

       234
       234
       -
       	var shas []string

     

       235
       235
       -
       	for _, c := range xrpcResp.Commits {

     

       236
       236
       -
       		shas = append(shas, c.Hash.String())

     

       237
       237
       -
       	}

     

       238
       238
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       239
       239
       -
       	if err != nil {

     

       240
       240
       -
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       241
       241
       -
       		// non-fatal

     

       242
       242
       -
       	}

     

       243
       243
       -
       

     

       244
       244
       -
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       245
       245
       -
       		LoggedInUser:       user,

     

       246
       246
       -
       		TagMap:             tagMap,

     

       247
       247
       -
       		RepoInfo:           repoInfo,

     

       248
       248
       -
       		RepoLogResponse:    xrpcResp,

     

       249
       249
       -
       		EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),

     

       250
       250
       -
       		VerifiedCommits:    vc,

     

       251
       251
       -
       		Pipelines:          pipelines,

     

       252
       252
       -
       	})

     

       253
       253
       -
       }

     

       254
       254
       -
       

     

       255
       255
       -
       func (rp *Repo) RepoDescriptionEdit(w http.ResponseWriter, r *http.Request) {

     

       256
       256
       -
       	l := rp.logger.With("handler", "RepoDescriptionEdit")

     

       257
       257
       -
       

     

       258
       258
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       259
       259
       -
       	if err != nil {

     

       260
       260
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       261
       261
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       262
       262
       -
       		return

     

       263
       263
       -
       	}

     

       264
       264
       -
       

     

       265
       265
       -
       	user := rp.oauth.GetUser(r)

     

       266
       266
       -
       	rp.pages.EditRepoDescriptionFragment(w, pages.RepoDescriptionParams{

     

       267
       267
       -
       		RepoInfo: f.RepoInfo(user),

     

       268
       268
       -
       	})

     

       269
       269
       -
       }

     

       270
       270
       -
       

     

       271
       271
       -
       func (rp *Repo) RepoDescription(w http.ResponseWriter, r *http.Request) {

     

       272
       272
       -
       	l := rp.logger.With("handler", "RepoDescription")

     

       273
       273
       -
       

     

       274
       274
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       275
       275
       -
       	if err != nil {

     

       276
       276
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       277
       277
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       278
       278
       -
       		return

     

       279
       279
       -
       	}

     

       280
       280
       -
       

     

       281
       281
       -
       	repoAt := f.RepoAt()

     

       282
       282
       -
       	rkey := repoAt.RecordKey().String()

     

       283
       283
       -
       	if rkey == "" {

     

       284
       284
       -
       		l.Error("invalid aturi for repo", "err", err)

     

       285
       285
       -
       		w.WriteHeader(http.StatusInternalServerError)

     

       286
       286
       -
       		return

     

       287
       287
       -
       	}

     

       288
       288
       -
       

     

       289
       289
       -
       	user := rp.oauth.GetUser(r)

     

       290
       290
       -
       

     

       291
       291
       -
       	switch r.Method {

     

       292
       292
       -
       	case http.MethodGet:

     

       293
       293
       -
       		rp.pages.RepoDescriptionFragment(w, pages.RepoDescriptionParams{

     

       294
       294
       -
       			RepoInfo: f.RepoInfo(user),

     

       295
       295
       -
       		})

     

       296
       296
       -
       		return

     

       297
       297
       -
       	case http.MethodPut:

     

       298
       298
       -
       		newDescription := r.FormValue("description")

     

       299
       299
       -
       		client, err := rp.oauth.AuthorizedClient(r)

     

       300
       300
       -
       		if err != nil {

     

       301
       301
       -
       			l.Error("failed to get client")

     

       302
       302
       -
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       303
       303
       -
       			return

     

       304
       304
       -
       		}

     

       305
       305
       -
       

     

       306
       306
       -
       		// optimistic update

     

       307
       307
       -
       		err = db.UpdateDescription(rp.db, string(repoAt), newDescription)

     

       308
       308
       -
       		if err != nil {

     

       309
       309
       -
       			l.Error("failed to perform update-description query", "err", err)

     

       310
       310
       -
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       311
       311
       -
       			return

     

       312
       312
       -
       		}

     

       313
       313
       -
       

     

       314
       314
       -
       		newRepo := f.Repo

     

       315
       315
       -
       		newRepo.Description = newDescription

     

       316
       316
       -
       		record := newRepo.AsRecord()

     

       317
       317
       -
       

     

       318
       318
       -
       		// this is a bit of a pain because the golang atproto impl does not allow nil SwapRecord field

     

       319
       319
       -
       		//

     

       320
       320
       -
       		// SwapRecord is optional and should happen automagically, but given that it does not, we have to perform two requests

     

       321
       321
       -
       		ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       322
       322
       -
       		if err != nil {

     

       323
       323
       -
       			// failed to get record

     

       324
       324
       -
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, no record found on PDS.")

     

       325
       325
       -
       			return

     

       326
       326
       -
       		}

     

       327
       327
       -
       		_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       328
       328
       -
       			Collection: tangled.RepoNSID,

     

       329
       329
       -
       			Repo:       newRepo.Did,

     

       330
       330
       -
       			Rkey:       newRepo.Rkey,

     

       331
       331
       -
       			SwapRecord: ex.Cid,

     

       332
       332
       -
       			Record: &lexutil.LexiconTypeDecoder{

     

       333
       333
       -
       				Val: &record,

     

       334
       334
       -
       			},

     

       335
       335
       -
       		})

     

       336
       336
       -
       

     

       337
       337
       -
       		if err != nil {

     

       338
       338
       -
       			l.Error("failed to perferom update-description query", "err", err)

     

       339
       339
       -
       			// failed to get record

     

       340
       340
       -
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, unable to save to PDS.")

     

       341
       341
       -
       			return

     

       342
       342
       -
       		}

     

       343
       343
       -
       

     

       344
       344
       -
       		newRepoInfo := f.RepoInfo(user)

     

       345
       345
       -
       		newRepoInfo.Description = newDescription

     

       346
       346
       -
       

     

       347
       347
       -
       		rp.pages.RepoDescriptionFragment(w, pages.RepoDescriptionParams{

     

       348
       348
       -
       			RepoInfo: newRepoInfo,

     

       349
       349
       -
       		})

     

       350
       350
       -
       		return

     

       351
       351
       -
       	}

     

       352
       352
       -
       }

     

       353
       353
       -
       

     

       354
       354
       -
       func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) {

     

       355
       355
       -
       	l := rp.logger.With("handler", "RepoCommit")

     

       356
       356
       -
       

     

       357
       357
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       358
       358
       -
       	if err != nil {

     

       359
       359
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       360
       360
       -
       		return

     

       361
       361
       -
       	}

     

       362
       362
       -
       	ref := chi.URLParam(r, "ref")

     

       363
       363
       -
       	ref, _ = url.PathUnescape(ref)

     

       364
       364
       -
       

     

       365
       365
       -
       	var diffOpts types.DiffOpts

     

       366
       366
       -
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       367
       367
       -
       		diffOpts.Split = true

     

       368
       368
       -
       	}

     

       369
       369
       -
       

     

       370
       370
       -
       	if !plumbing.IsHash(ref) {

     

       371
       371
       -
       		rp.pages.Error404(w)

     

       372
       372
       -
       		return

     

       373
       373
       -
       	}

     

       374
       374
       -
       

     

       375
       375
       -
       	scheme := "http"

     

       376
       376
       -
       	if !rp.config.Core.Dev {

     

       377
       377
       -
       		scheme = "https"

     

       378
       378
       -
       	}

     

       379
       379
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       380
       380
       -
       	xrpcc := &indigoxrpc.Client{

     

       381
       381
       -
       		Host: host,

     

       382
       382
       -
       	}

     

       383
       383
       -
       

     

       384
       384
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       385
       385
       -
       	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       386
       386
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       387
       387
       -
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       388
       388
       -
       		rp.pages.Error503(w)

     

       389
       389
       -
       		return

     

       390
       390
       -
       	}

     

       391
       391
       -
       

     

       392
       392
       -
       	var result types.RepoCommitResponse

     

       393
       393
       -
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       394
       394
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       395
       395
       -
       		rp.pages.Error503(w)

     

       396
       396
       -
       		return

     

       397
       397
       -
       	}

     

       398
       398
       -
       

     

       399
       399
       -
       	emailToDidMap, err := db.GetEmailToDid(rp.db, []string{result.Diff.Commit.Committer.Email, result.Diff.Commit.Author.Email}, true)

     

       400
       400
       -
       	if err != nil {

     

       401
       401
       -
       		l.Error("failed to get email to did mapping", "err", err)

     

       402
       402
       -
       	}

     

       403
       403
       -
       

     

       404
       404
       -
       	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.NiceDiff{*result.Diff})

     

       405
       405
       -
       	if err != nil {

     

       406
       406
       -
       		l.Error("failed to GetVerifiedCommits", "err", err)

     

       407
       407
       -
       	}

     

       408
       408
       -
       

     

       409
       409
       -
       	user := rp.oauth.GetUser(r)

     

       410
       410
       -
       	repoInfo := f.RepoInfo(user)

     

       411
       411
       -
       	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

       412
       412
       -
       	if err != nil {

     

       413
       413
       -
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       414
       414
       -
       		// non-fatal

     

       415
       415
       -
       	}

     

       416
       416
       -
       	var pipeline *models.Pipeline

     

       417
       417
       -
       	if p, ok := pipelines[result.Diff.Commit.This]; ok {

     

       418
       418
       -
       		pipeline = &p

     

       419
       419
       -
       	}

     

       420
       420
       -
       

     

       421
       421
       -
       	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       422
       422
       -
       		LoggedInUser:       user,

     

       423
       423
       -
       		RepoInfo:           f.RepoInfo(user),

     

       424
       424
       -
       		RepoCommitResponse: result,

     

       425
       425
       -
       		EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),

     

       426
       426
       -
       		VerifiedCommit:     vc,

     

       427
       427
       -
       		Pipeline:           pipeline,

     

       428
       428
       -
       		DiffOpts:           diffOpts,

     

       429
       429
       -
       	})

     

       430
       430
       -
       }

     

       431
       431
       -
       

     

       432
       432
       -
       func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       433
       433
       -
       	l := rp.logger.With("handler", "RepoTree")

     

       434
       434
       -
       

     

       435
       435
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       436
       436
       -
       	if err != nil {

     

       437
       437
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       438
       438
       -
       		return

     

       439
       439
       -
       	}

     

       440
       440
       -
       

     

       441
       441
       -
       	ref := chi.URLParam(r, "ref")

     

       442
       442
       -
       	ref, _ = url.PathUnescape(ref)

     

       443
       443
       -
       

     

       444
       444
       -
       	// if the tree path has a trailing slash, let's strip it

     

       445
       445
       -
       	// so we don't 404

     

       446
       446
       -
       	treePath := chi.URLParam(r, "*")

     

       447
       447
       -
       	treePath, _ = url.PathUnescape(treePath)

     

       448
       448
       -
       	treePath = strings.TrimSuffix(treePath, "/")

     

       449
       449
       -
       

     

       450
       450
       -
       	scheme := "http"

     

       451
       451
       -
       	if !rp.config.Core.Dev {

     

       452
       452
       -
       		scheme = "https"

     

       453
       453
       -
       	}

     

       454
       454
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       455
       455
       -
       	xrpcc := &indigoxrpc.Client{

     

       456
       456
       -
       		Host: host,

     

       457
       457
       -
       	}

     

       458
       458
       -
       

     

       459
       459
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       460
       460
       -
       	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       461
       461
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       462
       462
       -
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       463
       463
       -
       		rp.pages.Error503(w)

     

       464
       464
       -
       		return

     

       465
       465
       -
       	}

     

       466
       466
       -
       

     

       467
       467
       -
       	// Convert XRPC response to internal types.RepoTreeResponse

     

       468
       468
       -
       	files := make([]types.NiceTree, len(xrpcResp.Files))

     

       469
       469
       -
       	for i, xrpcFile := range xrpcResp.Files {

     

       470
       470
       -
       		file := types.NiceTree{

     

       471
       471
       -
       			Name:      xrpcFile.Name,

     

       472
       472
       -
       			Mode:      xrpcFile.Mode,

     

       473
       473
       -
       			Size:      int64(xrpcFile.Size),

     

       474
       474
       -
       			IsFile:    xrpcFile.Is_file,

     

       475
       475
       -
       			IsSubtree: xrpcFile.Is_subtree,

     

       476
       476
       -
       		}

     

       477
       477
       -
       

     

       478
       478
       -
       		// Convert last commit info if present

     

       479
       479
       -
       		if xrpcFile.Last_commit != nil {

     

       480
       480
       -
       			commitWhen, _ := time.Parse(time.RFC3339, xrpcFile.Last_commit.When)

     

       481
       481
       -
       			file.LastCommit = &types.LastCommitInfo{

     

       482
       482
       -
       				Hash:    plumbing.NewHash(xrpcFile.Last_commit.Hash),

     

       483
       483
       -
       				Message: xrpcFile.Last_commit.Message,

     

       484
       484
       -
       				When:    commitWhen,

     

       485
       485
       -
       			}

     

       486
       486
       -
       		}

     

       487
       487
       -
       

     

       488
       488
       -
       		files[i] = file

     

       489
       489
       -
       	}

     

       490
       490
       -
       

     

       491
       491
       -
       	result := types.RepoTreeResponse{

     

       492
       492
       -
       		Ref:   xrpcResp.Ref,

     

       493
       493
       -
       		Files: files,

     

       494
       494
       -
       	}

     

       495
       495
       -
       

     

       496
       496
       -
       	if xrpcResp.Parent != nil {

     

       497
       497
       -
       		result.Parent = *xrpcResp.Parent

     

       498
       498
       -
       	}

     

       499
       499
       -
       	if xrpcResp.Dotdot != nil {

     

       500
       500
       -
       		result.DotDot = *xrpcResp.Dotdot

     

       501
       501
       -
       	}

     

       502
       502
       -
       	if xrpcResp.Readme != nil {

     

       503
       503
       -
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       504
       504
       -
       		result.Readme = xrpcResp.Readme.Contents

     

       505
       505
       -
       	}

     

       506
       506
       -
       

     

       507
       507
       -
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       508
       508
       -
       	// so we can safely redirect to the "parent" (which is the same file).

     

       509
       509
       -
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       510
       510
       -
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent)

     

       511
       511
       -
       		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       512
       512
       -
       		return

     

       513
       513
       -
       	}

     

       514
       514
       -
       

     

       515
       515
       -
       	user := rp.oauth.GetUser(r)

     

       516
       516
       -
       

     

       517
       517
       -
       	var breadcrumbs [][]string

     

       518
       518
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       519
       519
       -
       	if treePath != "" {

     

       520
       520
       -
       		for idx, elem := range strings.Split(treePath, "/") {

     

       521
       521
       -
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       522
       522
       -
       		}

     

       523
       523
       -
       	}

     

       524
       524
       -
       

     

       525
       525
       -
       	sortFiles(result.Files)

     

       526
       526
       -
       

     

       527
       527
       -
       	rp.pages.RepoTree(w, pages.RepoTreeParams{

     

       528
       528
       -
       		LoggedInUser:     user,

     

       529
       529
       -
       		BreadCrumbs:      breadcrumbs,

     

       530
       530
       -
       		TreePath:         treePath,

     

       531
       531
       -
       		RepoInfo:         f.RepoInfo(user),

     

       532
       532
       -
       		RepoTreeResponse: result,

     

       533
       533
       -
       	})

     

       534
       534
       -
       }

     

       535
       535
       -
       

     

       536
       536
       -
       func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       537
       537
       -
       	l := rp.logger.With("handler", "RepoTags")

     

       538
       538
       -
       

     

       539
       539
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       540
       540
       -
       	if err != nil {

     

       541
       541
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       542
       542
       -
       		return

     

       543
       543
       -
       	}

     

       544
       544
       -
       

     

       545
       545
       -
       	scheme := "http"

     

       546
       546
       -
       	if !rp.config.Core.Dev {

     

       547
       547
       -
       		scheme = "https"

     

       548
       548
       -
       	}

     

       549
       549
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       550
       550
       -
       	xrpcc := &indigoxrpc.Client{

     

       551
       551
       -
       		Host: host,

     

       552
       552
       -
       	}

     

       553
       553
       -
       

     

       554
       554
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       555
       555
       -
       	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       556
       556
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       557
       557
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       558
       558
       -
       		rp.pages.Error503(w)

     

       559
       559
       -
       		return

     

       560
       560
       -
       	}

     

       561
       561
       -
       

     

       562
       562
       -
       	var result types.RepoTagsResponse

     

       563
       563
       -
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       564
       564
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       565
       565
       -
       		rp.pages.Error503(w)

     

       566
       566
       -
       		return

     

       567
       567
       -
       	}

     

       568
       568
       -
       

     

       569
       569
       -
       	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))

     

       570
       570
       -
       	if err != nil {

     

       571
       571
       -
       		l.Error("failed grab artifacts", "err", err)

     

       572
       572
       -
       		return

     

       573
       573
       -
       	}

     

       574
       574
       -
       

     

       575
       575
       -
       	// convert artifacts to map for easy UI building

     

       576
       576
       -
       	artifactMap := make(map[plumbing.Hash][]models.Artifact)

     

       577
       577
       -
       	for _, a := range artifacts {

     

       578
       578
       -
       		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       579
       579
       -
       	}

     

       580
       580
       -
       

     

       581
       581
       -
       	var danglingArtifacts []models.Artifact

     

       582
       582
       -
       	for _, a := range artifacts {

     

       583
       583
       -
       		found := false

     

       584
       584
       -
       		for _, t := range result.Tags {

     

       585
       585
       -
       			if t.Tag != nil {

     

       586
       586
       -
       				if t.Tag.Hash == a.Tag {

     

       587
       587
       -
       					found = true

     

       588
       588
       -
       				}

     

       589
       589
       -
       			}

     

       590
       590
       -
       		}

     

       591
       591
       -
       

     

       592
       592
       -
       		if !found {

     

       593
       593
       -
       			danglingArtifacts = append(danglingArtifacts, a)

     

       594
       594
       -
       		}

     

       595
       595
       -
       	}

     

       596
       596
       -
       

     

       597
       597
       -
       	user := rp.oauth.GetUser(r)

     

       598
       598
       -
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       599
       599
       -
       		LoggedInUser:      user,

     

       600
       600
       -
       		RepoInfo:          f.RepoInfo(user),

     

       601
       601
       -
       		RepoTagsResponse:  result,

     

       602
       602
       -
       		ArtifactMap:       artifactMap,

     

       603
       603
       -
       		DanglingArtifacts: danglingArtifacts,

     

       604
       604
       -
       	})

     

       605
       605
       -
       }

     

       606
       606
       -
       

     

       607
       607
       -
       func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       608
       608
       -
       	l := rp.logger.With("handler", "RepoBranches")

     

       609
       609
       -
       

     

       610
       610
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       611
       611
       -
       	if err != nil {

     

       612
       612
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       613
       613
       -
       		return

     

       614
       614
       -
       	}

     

       615
       615
       -
       

     

       616
       616
       -
       	scheme := "http"

     

       617
       617
       -
       	if !rp.config.Core.Dev {

     

       618
       618
       -
       		scheme = "https"

     

       619
       619
       -
       	}

     

       620
       620
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       621
       621
       -
       	xrpcc := &indigoxrpc.Client{

     

       622
       622
       -
       		Host: host,

     

       623
       623
       -
       	}

     

       624
       624
       -
       

     

       625
       625
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       626
       626
       -
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       627
       627
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       628
       628
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       629
       629
       -
       		rp.pages.Error503(w)

     

       630
       630
       -
       		return

     

       631
       631
       -
       	}

     

       632
       632
       -
       

     

       633
       633
       -
       	var result types.RepoBranchesResponse

     

       634
       634
       -
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       635
       635
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       636
       636
       -
       		rp.pages.Error503(w)

     

       637
       637
       -
       		return

     

       638
       638
       -
       	}

     

       639
       639
       -
       

     

       640
       640
       -
       	sortBranches(result.Branches)

     

       641
       641
       -
       

     

       642
       642
       -
       	user := rp.oauth.GetUser(r)

     

       643
       643
       -
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       644
       644
       -
       		LoggedInUser:         user,

     

       645
       645
       -
       		RepoInfo:             f.RepoInfo(user),

     

       646
       646
       -
       		RepoBranchesResponse: result,

     

       647
       647
       -
       	})

     

       648
       648
       -
       }

     

       649
       649
       -
       

     

       650
       650
       -
       func (rp *Repo) DeleteBranch(w http.ResponseWriter, r *http.Request) {

     

       651
       651
       -
       	l := rp.logger.With("handler", "DeleteBranch")

     

       652
       652
       -
       

     

       653
       653
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       654
       654
       -
       	if err != nil {

     

       655
       655
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       656
       656
       -
       		return

     

       657
       657
       -
       	}

     

       658
       658
       -
       

     

       659
       659
       -
       	noticeId := "delete-branch-error"

     

       660
       660
       -
       	fail := func(msg string, err error) {

     

       661
       661
       -
       		l.Error(msg, "err", err)

     

       662
       662
       -
       		rp.pages.Notice(w, noticeId, msg)

     

       663
       663
       -
       	}

     

       664
       664
       -
       

     

       665
       665
       -
       	branch := r.FormValue("branch")

     

       666
       666
       -
       	if branch == "" {

     

       667
       667
       -
       		fail("No branch provided.", nil)

     

       668
       668
       -
       		return

     

       669
       669
       -
       	}

     

       670
       670
       -
       

     

       671
       671
       -
       	client, err := rp.oauth.ServiceClient(

     

       672
       672
       -
       		r,

     

       673
       673
       -
       		oauth.WithService(f.Knot),

     

       674
       674
       -
       		oauth.WithLxm(tangled.RepoDeleteBranchNSID),

     

       675
       675
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       676
       676
       -
       	)

     

       677
       677
       -
       	if err != nil {

     

       678
       678
       -
       		fail("Failed to connect to knotserver", nil)

     

       679
       679
       -
       		return

     

       680
       680
       -
       	}

     

       681
       681
       -
       

     

       682
       682
       -
       	err = tangled.RepoDeleteBranch(

     

       683
       683
       -
       		r.Context(),

     

       684
       684
       -
       		client,

     

       685
       685
       -
       		&tangled.RepoDeleteBranch_Input{

     

       686
       686
       -
       			Branch: branch,

     

       687
       687
       -
       			Repo:   f.RepoAt().String(),

     

       688
       688
       -
       		},

     

       689
       689
       -
       	)

     

       690
       690
       -
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       691
       691
       -
       		fail(fmt.Sprintf("Failed to delete branch: %s", err), err)

     

       692
       692
       -
       		return

     

       693
       693
       -
       	}

     

       694
       694
       -
       	l.Error("deleted branch from knot", "branch", branch, "repo", f.RepoAt())

     

       695
       695
       -
       

     

       696
       696
       -
       	rp.pages.HxRefresh(w)

     

       697
       697
       -
       }

     

       698
       698
       -
       

     

       699
       699
       -
       func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       700
       700
       -
       	l := rp.logger.With("handler", "RepoBlob")

     

       701
       701
       -
       

     

       702
       702
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       703
       703
       -
       	if err != nil {

     

       704
       704
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       705
       705
       -
       		return

     

       706
       706
       -
       	}

     

       707
       707
       -
       

     

       708
       708
       -
       	ref := chi.URLParam(r, "ref")

     

       709
       709
       -
       	ref, _ = url.PathUnescape(ref)

     

       710
       710
       -
       

     

       711
       711
       -
       	filePath := chi.URLParam(r, "*")

     

       712
       712
       -
       	filePath, _ = url.PathUnescape(filePath)

     

       713
       713
       -
       

     

       714
       714
       -
       	scheme := "http"

     

       715
       715
       -
       	if !rp.config.Core.Dev {

     

       716
       716
       -
       		scheme = "https"

     

       717
       717
       -
       	}

     

       718
       718
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       719
       719
       -
       	xrpcc := &indigoxrpc.Client{

     

       720
       720
       -
       		Host: host,

     

       721
       721
       -
       	}

     

       722
       722
       -
       

     

       723
       723
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)

     

       724
       724
       -
       	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       725
       725
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       726
       726
       -
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       727
       727
       -
       		rp.pages.Error503(w)

     

       728
       728
       -
       		return

     

       729
       729
       -
       	}

     

       730
       730
       -
       

     

       731
       731
       -
       	// Use XRPC response directly instead of converting to internal types

     

       732
       732
       -
       

     

       733
       733
       -
       	var breadcrumbs [][]string

     

       734
       734
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       735
       735
       -
       	if filePath != "" {

     

       736
       736
       -
       		for idx, elem := range strings.Split(filePath, "/") {

     

       737
       737
       -
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       738
       738
       -
       		}

     

       739
       739
       -
       	}

     

       740
       740
       -
       

     

       741
       741
       -
       	showRendered := false

     

       742
       742
       -
       	renderToggle := false

     

       743
       743
       -
       

     

       744
       744
       -
       	if markup.GetFormat(resp.Path) == markup.FormatMarkdown {

     

       745
       745
       -
       		renderToggle = true

     

       746
       746
       -
       		showRendered = r.URL.Query().Get("code") != "true"

     

       747
       747
       -
       	}

     

       748
       748
       -
       

     

       749
       749
       -
       	var unsupported bool

     

       750
       750
       -
       	var isImage bool

     

       751
       751
       -
       	var isVideo bool

     

       752
       752
       -
       	var contentSrc string

     

       753
       753
       -
       

     

       754
       754
       -
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       755
       755
       -
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       756
       756
       -
       		switch ext {

     

       757
       757
       -
       		case ".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp":

     

       758
       758
       -
       			isImage = true

     

       759
       759
       -
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       760
       760
       -
       			isVideo = true

     

       761
       761
       -
       		default:

     

       762
       762
       -
       			unsupported = true

     

       763
       763
       -
       		}

     

       764
       764
       -
       

     

       765
       765
       -
       		// fetch the raw binary content using sh.tangled.repo.blob xrpc

     

       766
       766
       -
       		repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       767
       767
       -
       

     

       768
       768
       -
       		baseURL := &url.URL{

     

       769
       769
       -
       			Scheme: scheme,

     

       770
       770
       -
       			Host:   f.Knot,

     

       771
       771
       -
       			Path:   "/xrpc/sh.tangled.repo.blob",

     

       772
       772
       -
       		}

     

       773
       773
       -
       		query := baseURL.Query()

     

       774
       774
       -
       		query.Set("repo", repoName)

     

       775
       775
       -
       		query.Set("ref", ref)

     

       776
       776
       -
       		query.Set("path", filePath)

     

       777
       777
       -
       		query.Set("raw", "true")

     

       778
       778
       -
       		baseURL.RawQuery = query.Encode()

     

       779
       779
       -
       		blobURL := baseURL.String()

     

       780
       780
       -
       

     

       781
       781
       -
       		contentSrc = blobURL

     

       782
       782
       -
       		if !rp.config.Core.Dev {

     

       783
       783
       -
       			contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)

     

       784
       784
       -
       		}

     

       785
       785
       -
       	}

     

       786
       786
       -
       

     

       787
       787
       -
       	lines := 0

     

       788
       788
       -
       	if resp.IsBinary == nil || !*resp.IsBinary {

     

       789
       789
       -
       		lines = strings.Count(resp.Content, "\n") + 1

     

       790
       790
       -
       	}

     

       791
       791
       -
       

     

       792
       792
       -
       	var sizeHint uint64

     

       793
       793
       -
       	if resp.Size != nil {

     

       794
       794
       -
       		sizeHint = uint64(*resp.Size)

     

       795
       795
       -
       	} else {

     

       796
       796
       -
       		sizeHint = uint64(len(resp.Content))

     

       797
       797
       -
       	}

     

       798
       798
       -
       

     

       799
       799
       -
       	user := rp.oauth.GetUser(r)

     

       800
       800
       -
       

     

       801
       801
       -
       	// Determine if content is binary (dereference pointer)

     

       802
       802
       -
       	isBinary := false

     

       803
       803
       -
       	if resp.IsBinary != nil {

     

       804
       804
       -
       		isBinary = *resp.IsBinary

     

       805
       805
       -
       	}

     

       806
       806
       -
       

     

       807
       807
       -
       	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       808
       808
       -
       		LoggedInUser:    user,

     

       809
       809
       -
       		RepoInfo:        f.RepoInfo(user),

     

       810
       810
       -
       		BreadCrumbs:     breadcrumbs,

     

       811
       811
       -
       		ShowRendered:    showRendered,

     

       812
       812
       -
       		RenderToggle:    renderToggle,

     

       813
       813
       -
       		Unsupported:     unsupported,

     

       814
       814
       -
       		IsImage:         isImage,

     

       815
       815
       -
       		IsVideo:         isVideo,

     

       816
       816
       -
       		ContentSrc:      contentSrc,

     

       817
       817
       -
       		RepoBlob_Output: resp,

     

       818
       818
       -
       		Contents:        resp.Content,

     

       819
       819
       -
       		Lines:           lines,

     

       820
       820
       -
       		SizeHint:        sizeHint,

     

       821
       821
       -
       		IsBinary:        isBinary,

     

       822
       822
       -
       	})

     

       823
       823
       -
       }

     

       824
       824
       -
       

     

       825
       825
       -
       func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       826
       826
       -
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       827
       827
       -
       

     

       828
       828
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       829
       829
       -
       	if err != nil {

     

       830
       830
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       831
       831
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       832
       832
       -
       		return

     

       833
       833
       -
       	}

     

       834
       834
       -
       

     

       835
       835
       -
       	ref := chi.URLParam(r, "ref")

     

       836
       836
       -
       	ref, _ = url.PathUnescape(ref)

     

       837
       837
       -
       

     

       838
       838
       -
       	filePath := chi.URLParam(r, "*")

     

       839
       839
       -
       	filePath, _ = url.PathUnescape(filePath)

     

       840
       840
       -
       

     

       841
       841
       -
       	scheme := "http"

     

       842
       842
       -
       	if !rp.config.Core.Dev {

     

       843
       843
       -
       		scheme = "https"

     

       844
       844
       -
       	}

     

       845
       845
       -
       

     

       846
       846
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)

     

       847
       847
       -
       	baseURL := &url.URL{

     

       848
       848
       -
       		Scheme: scheme,

     

       849
       849
       -
       		Host:   f.Knot,

     

       850
       850
       -
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       851
       851
       -
       	}

     

       852
       852
       -
       	query := baseURL.Query()

     

       853
       853
       -
       	query.Set("repo", repo)

     

       854
       854
       -
       	query.Set("ref", ref)

     

       855
       855
       -
       	query.Set("path", filePath)

     

       856
       856
       -
       	query.Set("raw", "true")

     

       857
       857
       -
       	baseURL.RawQuery = query.Encode()

     

       858
       858
       -
       	blobURL := baseURL.String()

     

       859
       859
       -
       

     

       860
       860
       -
       	req, err := http.NewRequest("GET", blobURL, nil)

     

       861
       861
       -
       	if err != nil {

     

       862
       862
       -
       		l.Error("failed to create request", "err", err)

     

       863
       863
       -
       		return

     

       864
       864
       -
       	}

     

       865
       865
       -
       

     

       866
       866
       -
       	// forward the If-None-Match header

     

       867
       867
       -
       	if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {

     

       868
       868
       -
       		req.Header.Set("If-None-Match", clientETag)

     

       869
       869
       -
       	}

     

       870
       870
       -
       

     

       871
       871
       -
       	client := &http.Client{}

     

       872
       872
       -
       	resp, err := client.Do(req)

     

       873
       873
       -
       	if err != nil {

     

       874
       874
       -
       		l.Error("failed to reach knotserver", "err", err)

     

       875
       875
       -
       		rp.pages.Error503(w)

     

       876
       876
       -
       		return

     

       877
       877
       -
       	}

     

       878
       878
       -
       	defer resp.Body.Close()

     

       879
       879
       -
       

     

       880
       880
       -
       	// forward 304 not modified

     

       881
       881
       -
       	if resp.StatusCode == http.StatusNotModified {

     

       882
       882
       -
       		w.WriteHeader(http.StatusNotModified)

     

       883
       883
       -
       		return

     

       884
       884
       -
       	}

     

       885
       885
       -
       

     

       886
       886
       -
       	if resp.StatusCode != http.StatusOK {

     

       887
       887
       -
       		l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode)

     

       888
       888
       -
       		w.WriteHeader(resp.StatusCode)

     

       889
       889
       -
       		_, _ = io.Copy(w, resp.Body)

     

       890
       890
       -
       		return

     

       891
       891
       -
       	}

     

       892
       892
       -
       

     

       893
       893
       -
       	contentType := resp.Header.Get("Content-Type")

     

       894
       894
       -
       	body, err := io.ReadAll(resp.Body)

     

       895
       895
       -
       	if err != nil {

     

       896
       896
       -
       		l.Error("error reading response body from knotserver", "err", err)

     

       897
       897
       -
       		w.WriteHeader(http.StatusInternalServerError)

     

       898
       898
       -
       		return

     

       899
       899
       -
       	}

     

       900
       900
       -
       

     

       901
       901
       -
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       902
       902
       -
       		// serve all textual content as text/plain

     

       903
       903
       -
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       904
       904
       -
       		w.Write(body)

     

       905
       905
       -
       	} else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {

     

       906
       906
       -
       		// serve images and videos with their original content type

     

       907
       907
       -
       		w.Header().Set("Content-Type", contentType)

     

       908
       908
       -
       		w.Write(body)

     

       909
       909
       -
       	} else {

     

       910
       910
       -
       		w.WriteHeader(http.StatusUnsupportedMediaType)

     

       911
       911
       -
       		w.Write([]byte("unsupported content type"))

     

       912
       912
       -
       		return

     

       913
       913
       -
       	}

     

       914
       914
       -
       }

     

       915
       915
       -
       

     

       916
       916
       -
       // isTextualMimeType returns true if the MIME type represents textual content

     

       917
       917
       -
       // that should be served as text/plain

     

       918
       918
       -
       func isTextualMimeType(mimeType string) bool {

     

       919
       919
       -
       	textualTypes := []string{

     

       920
       920
       -
       		"application/json",

     

       921
       921
       -
       		"application/xml",

     

       922
       922
       -
       		"application/yaml",

     

       923
       923
       -
       		"application/x-yaml",

     

       924
       924
       -
       		"application/toml",

     

       925
       925
       -
       		"application/javascript",

     

       926
       926
       -
       		"application/ecmascript",

     

       927
       927
       -
       		"message/",

     

       928
       928
       -
       	}

     

       929
       929
       -
       

     

       930
       930
       -
       	return slices.Contains(textualTypes, mimeType)

     

       931
       931
       -
       }

     

       932
       932
       -
       

     

       933
       82
        
       // modify the spindle configured for this repo

     

       934
       83
        
       func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {

     

       935
       84
        
       	user := rp.oauth.GetUser(r)

     
···

       970
       119
        
       		}

     

       971
       120
        
       	}

     

       972
       121
        
       

     

       973
       973
       -
       	newRepo := f.Repo

     

       122
       122
       +
       	newRepo := *f

     

       974
       123
        
       	newRepo.Spindle = newSpindle

     

       975
       124
        
       	record := newRepo.AsRecord()

     

       976
       125
        
       

     
···

       1109
       258
        
       	l.Info("wrote label record to PDS")

     

       1110
       259
        
       

     

       1111
       260
        
       	// update the repo to subscribe to this label

     

       1112
       1112
       -
       	newRepo := f.Repo

     

       261
       261
       +
       	newRepo := *f

     

       1113
       262
        
       	newRepo.Labels = append(newRepo.Labels, aturi)

     

       1114
       263
        
       	repoRecord := newRepo.AsRecord()

     

       1115
       264
        
       

     
···

       1197
       346
        
       	// get form values

     

       1198
       347
        
       	labelId := r.FormValue("label-id")

     

       1199
       348
        
       

     

       1200
       1200
       -
       	label, err := db.GetLabelDefinition(rp.db, db.FilterEq("id", labelId))

     

       349
       349
       +
       	label, err := db.GetLabelDefinition(rp.db, orm.FilterEq("id", labelId))

     

       1201
       350
        
       	if err != nil {

     

       1202
       351
        
       		fail("Failed to find label definition.", err)

     

       1203
       352
        
       		return

     
···

       1221
       370
        
       	}

     

       1222
       371
        
       

     

       1223
       372
        
       	// update repo record to remove the label reference

     

       1224
       1224
       -
       	newRepo := f.Repo

     

       373
       373
       +
       	newRepo := *f

     

       1225
       374
        
       	var updated []string

     

       1226
       375
        
       	removedAt := label.AtUri().String()

     

       1227
       376
        
       	for _, l := range newRepo.Labels {

     
···

       1261
       410
        
       

     

       1262
       411
        
       	err = db.UnsubscribeLabel(

     

       1263
       412
        
       		tx,

     

       1264
       1264
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       1265
       1265
       -
       		db.FilterEq("label_at", removedAt),

     

       413
       413
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       414
       414
       +
       		orm.FilterEq("label_at", removedAt),

     

       1266
       415
        
       	)

     

       1267
       416
        
       	if err != nil {

     

       1268
       417
        
       		fail("Failed to unsubscribe label.", err)

     

       1269
       418
        
       		return

     

       1270
       419
        
       	}

     

       1271
       420
        
       

     

       1272
       1272
       -
       	err = db.DeleteLabelDefinition(tx, db.FilterEq("id", label.Id))

     

       421
       421
       +
       	err = db.DeleteLabelDefinition(tx, orm.FilterEq("id", label.Id))

     

       1273
       422
        
       	if err != nil {

     

       1274
       423
        
       		fail("Failed to delete label definition.", err)

     

       1275
       424
        
       		return

     
···

       1308
       457
        
       	}

     

       1309
       458
        
       

     

       1310
       459
        
       	labelAts := r.Form["label"]

     

       1311
       1311
       -
       	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))

     

       460
       460
       +
       	_, err = db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", labelAts))

     

       1312
       461
        
       	if err != nil {

     

       1313
       462
        
       		fail("Failed to subscribe to label.", err)

     

       1314
       463
        
       		return

     

       1315
       464
        
       	}

     

       1316
       465
        
       

     

       1317
       1317
       -
       	newRepo := f.Repo

     

       466
       466
       +
       	newRepo := *f

     

       1318
       467
        
       	newRepo.Labels = append(newRepo.Labels, labelAts...)

     

       1319
       468
        
       

     

       1320
       469
        
       	// dedup

     
···

       1329
       478
        
       		return

     

       1330
       479
        
       	}

     

       1331
       480
        
       

     

       1332
       1332
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       481
       481
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       1333
       482
        
       	if err != nil {

     

       1334
       483
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       1335
       484
        
       		return

     
···

       1394
       543
        
       	}

     

       1395
       544
        
       

     

       1396
       545
        
       	labelAts := r.Form["label"]

     

       1397
       1397
       -
       	_, err = db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", labelAts))

     

       546
       546
       +
       	_, err = db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", labelAts))

     

       1398
       547
        
       	if err != nil {

     

       1399
       548
        
       		fail("Failed to unsubscribe to label.", err)

     

       1400
       549
        
       		return

     

       1401
       550
        
       	}

     

       1402
       551
        
       

     

       1403
       552
        
       	// update repo record to remove the label reference

     

       1404
       1404
       -
       	newRepo := f.Repo

     

       553
       553
       +
       	newRepo := *f

     

       1405
       554
        
       	var updated []string

     

       1406
       555
        
       	for _, l := range newRepo.Labels {

     

       1407
       556
        
       		if !slices.Contains(labelAts, l) {

     
···

       1417
       566
        
       		return

     

       1418
       567
        
       	}

     

       1419
       568
        
       

     

       1420
       1420
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)

     

       569
       569
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)

     

       1421
       570
        
       	if err != nil {

     

       1422
       571
        
       		fail("Failed to update labels, no record found on PDS.", err)

     

       1423
       572
        
       		return

     
···

       1434
       583
        
       

     

       1435
       584
        
       	err = db.UnsubscribeLabel(

     

       1436
       585
        
       		rp.db,

     

       1437
       1437
       -
       		db.FilterEq("repo_at", f.RepoAt()),

     

       1438
       1438
       -
       		db.FilterIn("label_at", labelAts),

     

       586
       586
       +
       		orm.FilterEq("repo_at", f.RepoAt()),

     

       587
       587
       +
       		orm.FilterIn("label_at", labelAts),

     

       1439
       588
        
       	)

     

       1440
       589
        
       	if err != nil {

     

       1441
       590
        
       		fail("Failed to unsubscribe label.", err)

     
···

       1464
       613
        
       

     

       1465
       614
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       1466
       615
        
       		rp.db,

     

       1467
       1467
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       1468
       1468
       -
       		db.FilterContains("scope", subject.Collection().String()),

     

       616
       616
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       617
       617
       +
       		orm.FilterContains("scope", subject.Collection().String()),

     

       1469
       618
        
       	)

     

       1470
       619
        
       	if err != nil {

     

       1471
       620
        
       		l.Error("failed to fetch label defs", "err", err)

     
···

       1477
       626
        
       		defs[l.AtUri().String()] = &l

     

       1478
       627
        
       	}

     

       1479
       628
        
       

     

       1480
       1480
       -
       	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       629
       629
       +
       	states, err := db.GetLabels(rp.db, orm.FilterEq("subject", subject))

     

       1481
       630
        
       	if err != nil {

     

       1482
       631
        
       		l.Error("failed to build label state", "err", err)

     

       1483
       632
        
       		return

     
···

       1487
       636
        
       	user := rp.oauth.GetUser(r)

     

       1488
       637
        
       	rp.pages.LabelPanel(w, pages.LabelPanelParams{

     

       1489
       638
        
       		LoggedInUser: user,

     

       1490
       1490
       -
       		RepoInfo:     f.RepoInfo(user),

     

       639
       639
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       1491
       640
        
       		Defs:         defs,

     

       1492
       641
        
       		Subject:      subject.String(),

     

       1493
       642
        
       		State:        state,

     
···

       1512
       661
        
       

     

       1513
       662
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       1514
       663
        
       		rp.db,

     

       1515
       1515
       -
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       1516
       1516
       -
       		db.FilterContains("scope", subject.Collection().String()),

     

       664
       664
       +
       		orm.FilterIn("at_uri", f.Labels),

     

       665
       665
       +
       		orm.FilterContains("scope", subject.Collection().String()),

     

       1517
       666
        
       	)

     

       1518
       667
        
       	if err != nil {

     

       1519
       668
        
       		l.Error("failed to fetch labels", "err", err)

     
···

       1525
       674
        
       		defs[l.AtUri().String()] = &l

     

       1526
       675
        
       	}

     

       1527
       676
        
       

     

       1528
       1528
       -
       	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       677
       677
       +
       	states, err := db.GetLabels(rp.db, orm.FilterEq("subject", subject))

     

       1529
       678
        
       	if err != nil {

     

       1530
       679
        
       		l.Error("failed to build label state", "err", err)

     

       1531
       680
        
       		return

     
···

       1535
       684
        
       	user := rp.oauth.GetUser(r)

     

       1536
       685
        
       	rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{

     

       1537
       686
        
       		LoggedInUser: user,

     

       1538
       1538
       -
       		RepoInfo:     f.RepoInfo(user),

     

       687
       687
       +
       		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       1539
       688
        
       		Defs:         defs,

     

       1540
       689
        
       		Subject:      subject.String(),

     

       1541
       690
        
       		State:        state,

     
···

       1716
       865
        
       		r.Context(),

     

       1717
       866
        
       		client,

     

       1718
       867
        
       		&tangled.RepoDelete_Input{

     

       1719
       1719
       -
       			Did:  f.OwnerDid(),

     

       868
       868
       +
       			Did:  f.Did,

     

       1720
       869
        
       			Name: f.Name,

     

       1721
       870
        
       			Rkey: f.Rkey,

     

       1722
       871
        
       		},

     
···

       1754
       903
        
       	l.Info("removed collaborators")

     

       1755
       904
        
       

     

       1756
       905
        
       	// remove repo RBAC

     

       1757
       1757
       -
       	err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())

     

       906
       906
       +
       	err = rp.enforcer.RemoveRepo(f.Did, f.Knot, f.DidSlashRepo())

     

       1758
       907
        
       	if err != nil {

     

       1759
       908
        
       		rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")

     

       1760
       909
        
       		return

     

       1761
       910
        
       	}

     

       1762
       911
        
       

     

       1763
       912
        
       	// remove repo from db

     

       1764
       1764
       -
       	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)

     

       913
       913
       +
       	err = db.RemoveRepo(tx, f.Did, f.Name)

     

       1765
       914
        
       	if err != nil {

     

       1766
       915
        
       		rp.pages.Notice(w, noticeId, "Failed to update appview")

     

       1767
       916
        
       		return

     
···

       1782
       931
        
       		return

     

       1783
       932
        
       	}

     

       1784
       933
        
       

     

       1785
       1785
       -
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))

     

       1786
       1786
       -
       }

     

       1787
       1787
       -
       

     

       1788
       1788
       -
       func (rp *Repo) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       1789
       1789
       -
       	l := rp.logger.With("handler", "SetDefaultBranch")

     

       1790
       1790
       -
       

     

       1791
       1791
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       1792
       1792
       -
       	if err != nil {

     

       1793
       1793
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       1794
       1794
       -
       		return

     

       1795
       1795
       -
       	}

     

       1796
       1796
       -
       

     

       1797
       1797
       -
       	noticeId := "operation-error"

     

       1798
       1798
       -
       	branch := r.FormValue("branch")

     

       1799
       1799
       -
       	if branch == "" {

     

       1800
       1800
       -
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       1801
       1801
       -
       		return

     

       1802
       1802
       -
       	}

     

       1803
       1803
       -
       

     

       1804
       1804
       -
       	client, err := rp.oauth.ServiceClient(

     

       1805
       1805
       -
       		r,

     

       1806
       1806
       -
       		oauth.WithService(f.Knot),

     

       1807
       1807
       -
       		oauth.WithLxm(tangled.RepoSetDefaultBranchNSID),

     

       1808
       1808
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       1809
       1809
       -
       	)

     

       1810
       1810
       -
       	if err != nil {

     

       1811
       1811
       -
       		l.Error("failed to connect to knot server", "err", err)

     

       1812
       1812
       -
       		rp.pages.Notice(w, noticeId, "Failed to connect to knot server.")

     

       1813
       1813
       -
       		return

     

       1814
       1814
       -
       	}

     

       1815
       1815
       -
       

     

       1816
       1816
       -
       	xe := tangled.RepoSetDefaultBranch(

     

       1817
       1817
       -
       		r.Context(),

     

       1818
       1818
       -
       		client,

     

       1819
       1819
       -
       		&tangled.RepoSetDefaultBranch_Input{

     

       1820
       1820
       -
       			Repo:          f.RepoAt().String(),

     

       1821
       1821
       -
       			DefaultBranch: branch,

     

       1822
       1822
       -
       		},

     

       1823
       1823
       -
       	)

     

       1824
       1824
       -
       	if err := xrpcclient.HandleXrpcErr(xe); err != nil {

     

       1825
       1825
       -
       		l.Error("xrpc failed", "err", xe)

     

       1826
       1826
       -
       		rp.pages.Notice(w, noticeId, err.Error())

     

       1827
       1827
       -
       		return

     

       1828
       1828
       -
       	}

     

       1829
       1829
       -
       

     

       1830
       1830
       -
       	rp.pages.HxRefresh(w)

     

       1831
       1831
       -
       }

     

       1832
       1832
       -
       

     

       1833
       1833
       -
       func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {

     

       1834
       1834
       -
       	user := rp.oauth.GetUser(r)

     

       1835
       1835
       -
       	l := rp.logger.With("handler", "Secrets")

     

       1836
       1836
       -
       	l = l.With("did", user.Did)

     

       1837
       1837
       -
       

     

       1838
       1838
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       1839
       1839
       -
       	if err != nil {

     

       1840
       1840
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       1841
       1841
       -
       		return

     

       1842
       1842
       -
       	}

     

       1843
       1843
       -
       

     

       1844
       1844
       -
       	if f.Spindle == "" {

     

       1845
       1845
       -
       		l.Error("empty spindle cannot add/rm secret", "err", err)

     

       1846
       1846
       -
       		return

     

       1847
       1847
       -
       	}

     

       1848
       1848
       -
       

     

       1849
       1849
       -
       	lxm := tangled.RepoAddSecretNSID

     

       1850
       1850
       -
       	if r.Method == http.MethodDelete {

     

       1851
       1851
       -
       		lxm = tangled.RepoRemoveSecretNSID

     

       1852
       1852
       -
       	}

     

       1853
       1853
       -
       

     

       1854
       1854
       -
       	spindleClient, err := rp.oauth.ServiceClient(

     

       1855
       1855
       -
       		r,

     

       1856
       1856
       -
       		oauth.WithService(f.Spindle),

     

       1857
       1857
       -
       		oauth.WithLxm(lxm),

     

       1858
       1858
       -
       		oauth.WithExp(60),

     

       1859
       1859
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       1860
       1860
       -
       	)

     

       1861
       1861
       -
       	if err != nil {

     

       1862
       1862
       -
       		l.Error("failed to create spindle client", "err", err)

     

       1863
       1863
       -
       		return

     

       1864
       1864
       -
       	}

     

       1865
       1865
       -
       

     

       1866
       1866
       -
       	key := r.FormValue("key")

     

       1867
       1867
       -
       	if key == "" {

     

       1868
       1868
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       1869
       1869
       -
       		return

     

       1870
       1870
       -
       	}

     

       1871
       1871
       -
       

     

       1872
       1872
       -
       	switch r.Method {

     

       1873
       1873
       -
       	case http.MethodPut:

     

       1874
       1874
       -
       		errorId := "add-secret-error"

     

       1875
       1875
       -
       

     

       1876
       1876
       -
       		value := r.FormValue("value")

     

       1877
       1877
       -
       		if value == "" {

     

       1878
       1878
       -
       			w.WriteHeader(http.StatusBadRequest)

     

       1879
       1879
       -
       			return

     

       1880
       1880
       -
       		}

     

       1881
       1881
       -
       

     

       1882
       1882
       -
       		err = tangled.RepoAddSecret(

     

       1883
       1883
       -
       			r.Context(),

     

       1884
       1884
       -
       			spindleClient,

     

       1885
       1885
       -
       			&tangled.RepoAddSecret_Input{

     

       1886
       1886
       -
       				Repo:  f.RepoAt().String(),

     

       1887
       1887
       -
       				Key:   key,

     

       1888
       1888
       -
       				Value: value,

     

       1889
       1889
       -
       			},

     

       1890
       1890
       -
       		)

     

       1891
       1891
       -
       		if err != nil {

     

       1892
       1892
       -
       			l.Error("Failed to add secret.", "err", err)

     

       1893
       1893
       -
       			rp.pages.Notice(w, errorId, "Failed to add secret.")

     

       1894
       1894
       -
       			return

     

       1895
       1895
       -
       		}

     

       1896
       1896
       -
       

     

       1897
       1897
       -
       	case http.MethodDelete:

     

       1898
       1898
       -
       		errorId := "operation-error"

     

       1899
       1899
       -
       

     

       1900
       1900
       -
       		err = tangled.RepoRemoveSecret(

     

       1901
       1901
       -
       			r.Context(),

     

       1902
       1902
       -
       			spindleClient,

     

       1903
       1903
       -
       			&tangled.RepoRemoveSecret_Input{

     

       1904
       1904
       -
       				Repo: f.RepoAt().String(),

     

       1905
       1905
       -
       				Key:  key,

     

       1906
       1906
       -
       			},

     

       1907
       1907
       -
       		)

     

       1908
       1908
       -
       		if err != nil {

     

       1909
       1909
       -
       			l.Error("Failed to delete secret.", "err", err)

     

       1910
       1910
       -
       			rp.pages.Notice(w, errorId, "Failed to delete secret.")

     

       1911
       1911
       -
       			return

     

       1912
       1912
       -
       		}

     

       1913
       1913
       -
       	}

     

       1914
       1914
       -
       

     

       1915
       1915
       -
       	rp.pages.HxRefresh(w)

     

       1916
       1916
       -
       }

     

       1917
       1917
       -
       

     

       1918
       1918
       -
       type tab = map[string]any

     

       1919
       1919
       -
       

     

       1920
       1920
       -
       var (

     

       1921
       1921
       -
       	// would be great to have ordered maps right about now

     

       1922
       1922
       -
       	settingsTabs []tab = []tab{

     

       1923
       1923
       -
       		{"Name": "general", "Icon": "sliders-horizontal"},

     

       1924
       1924
       -
       		{"Name": "access", "Icon": "users"},

     

       1925
       1925
       -
       		{"Name": "pipelines", "Icon": "layers-2"},

     

       1926
       1926
       -
       	}

     

       1927
       1927
       -
       )

     

       1928
       1928
       -
       

     

       1929
       1929
       -
       func (rp *Repo) RepoSettings(w http.ResponseWriter, r *http.Request) {

     

       1930
       1930
       -
       	tabVal := r.URL.Query().Get("tab")

     

       1931
       1931
       -
       	if tabVal == "" {

     

       1932
       1932
       -
       		tabVal = "general"

     

       1933
       1933
       -
       	}

     

       1934
       1934
       -
       

     

       1935
       1935
       -
       	switch tabVal {

     

       1936
       1936
       -
       	case "general":

     

       1937
       1937
       -
       		rp.generalSettings(w, r)

     

       1938
       1938
       -
       

     

       1939
       1939
       -
       	case "access":

     

       1940
       1940
       -
       		rp.accessSettings(w, r)

     

       1941
       1941
       -
       

     

       1942
       1942
       -
       	case "pipelines":

     

       1943
       1943
       -
       		rp.pipelineSettings(w, r)

     

       1944
       1944
       -
       	}

     

       1945
       1945
       -
       }

     

       1946
       1946
       -
       

     

       1947
       1947
       -
       func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) {

     

       1948
       1948
       -
       	l := rp.logger.With("handler", "generalSettings")

     

       1949
       1949
       -
       

     

       1950
       1950
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       1951
       1951
       -
       	user := rp.oauth.GetUser(r)

     

       1952
       1952
       -
       

     

       1953
       1953
       -
       	scheme := "http"

     

       1954
       1954
       -
       	if !rp.config.Core.Dev {

     

       1955
       1955
       -
       		scheme = "https"

     

       1956
       1956
       -
       	}

     

       1957
       1957
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       1958
       1958
       -
       	xrpcc := &indigoxrpc.Client{

     

       1959
       1959
       -
       		Host: host,

     

       1960
       1960
       -
       	}

     

       1961
       1961
       -
       

     

       1962
       1962
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       1963
       1963
       -
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       1964
       1964
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       1965
       1965
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       1966
       1966
       -
       		rp.pages.Error503(w)

     

       1967
       1967
       -
       		return

     

       1968
       1968
       -
       	}

     

       1969
       1969
       -
       

     

       1970
       1970
       -
       	var result types.RepoBranchesResponse

     

       1971
       1971
       -
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       1972
       1972
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       1973
       1973
       -
       		rp.pages.Error503(w)

     

       1974
       1974
       -
       		return

     

       1975
       1975
       -
       	}

     

       1976
       1976
       -
       

     

       1977
       1977
       -
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))

     

       1978
       1978
       -
       	if err != nil {

     

       1979
       1979
       -
       		l.Error("failed to fetch labels", "err", err)

     

       1980
       1980
       -
       		rp.pages.Error503(w)

     

       1981
       1981
       -
       		return

     

       1982
       1982
       -
       	}

     

       1983
       1983
       -
       

     

       1984
       1984
       -
       	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       1985
       1985
       -
       	if err != nil {

     

       1986
       1986
       -
       		l.Error("failed to fetch labels", "err", err)

     

       1987
       1987
       -
       		rp.pages.Error503(w)

     

       1988
       1988
       -
       		return

     

       1989
       1989
       -
       	}

     

       1990
       1990
       -
       	// remove default labels from the labels list, if present

     

       1991
       1991
       -
       	defaultLabelMap := make(map[string]bool)

     

       1992
       1992
       -
       	for _, dl := range defaultLabels {

     

       1993
       1993
       -
       		defaultLabelMap[dl.AtUri().String()] = true

     

       1994
       1994
       -
       	}

     

       1995
       1995
       -
       	n := 0

     

       1996
       1996
       -
       	for _, l := range labels {

     

       1997
       1997
       -
       		if !defaultLabelMap[l.AtUri().String()] {

     

       1998
       1998
       -
       			labels[n] = l

     

       1999
       1999
       -
       			n++

     

       2000
       2000
       -
       		}

     

       2001
       2001
       -
       	}

     

       2002
       2002
       -
       	labels = labels[:n]

     

       2003
       2003
       -
       

     

       2004
       2004
       -
       	subscribedLabels := make(map[string]struct{})

     

       2005
       2005
       -
       	for _, l := range f.Repo.Labels {

     

       2006
       2006
       -
       		subscribedLabels[l] = struct{}{}

     

       2007
       2007
       -
       	}

     

       2008
       2008
       -
       

     

       2009
       2009
       -
       	// if there is atleast 1 unsubbed default label, show the "subscribe all" button,

     

       2010
       2010
       -
       	// if all default labels are subbed, show the "unsubscribe all" button

     

       2011
       2011
       -
       	shouldSubscribeAll := false

     

       2012
       2012
       -
       	for _, dl := range defaultLabels {

     

       2013
       2013
       -
       		if _, ok := subscribedLabels[dl.AtUri().String()]; !ok {

     

       2014
       2014
       -
       			// one of the default labels is not subscribed to

     

       2015
       2015
       -
       			shouldSubscribeAll = true

     

       2016
       2016
       -
       			break

     

       2017
       2017
       -
       		}

     

       2018
       2018
       -
       	}

     

       2019
       2019
       -
       

     

       2020
       2020
       -
       	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       2021
       2021
       -
       		LoggedInUser:       user,

     

       2022
       2022
       -
       		RepoInfo:           f.RepoInfo(user),

     

       2023
       2023
       -
       		Branches:           result.Branches,

     

       2024
       2024
       -
       		Labels:             labels,

     

       2025
       2025
       -
       		DefaultLabels:      defaultLabels,

     

       2026
       2026
       -
       		SubscribedLabels:   subscribedLabels,

     

       2027
       2027
       -
       		ShouldSubscribeAll: shouldSubscribeAll,

     

       2028
       2028
       -
       		Tabs:               settingsTabs,

     

       2029
       2029
       -
       		Tab:                "general",

     

       2030
       2030
       -
       	})

     

       2031
       2031
       -
       }

     

       2032
       2032
       -
       

     

       2033
       2033
       -
       func (rp *Repo) accessSettings(w http.ResponseWriter, r *http.Request) {

     

       2034
       2034
       -
       	l := rp.logger.With("handler", "accessSettings")

     

       2035
       2035
       -
       

     

       2036
       2036
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       2037
       2037
       -
       	user := rp.oauth.GetUser(r)

     

       2038
       2038
       -
       

     

       2039
       2039
       -
       	repoCollaborators, err := f.Collaborators(r.Context())

     

       2040
       2040
       -
       	if err != nil {

     

       2041
       2041
       -
       		l.Error("failed to get collaborators", "err", err)

     

       2042
       2042
       -
       	}

     

       2043
       2043
       -
       

     

       2044
       2044
       -
       	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       2045
       2045
       -
       		LoggedInUser:  user,

     

       2046
       2046
       -
       		RepoInfo:      f.RepoInfo(user),

     

       2047
       2047
       -
       		Tabs:          settingsTabs,

     

       2048
       2048
       -
       		Tab:           "access",

     

       2049
       2049
       -
       		Collaborators: repoCollaborators,

     

       2050
       2050
       -
       	})

     

       2051
       2051
       -
       }

     

       2052
       2052
       -
       

     

       2053
       2053
       -
       func (rp *Repo) pipelineSettings(w http.ResponseWriter, r *http.Request) {

     

       2054
       2054
       -
       	l := rp.logger.With("handler", "pipelineSettings")

     

       2055
       2055
       -
       

     

       2056
       2056
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       2057
       2057
       -
       	user := rp.oauth.GetUser(r)

     

       2058
       2058
       -
       

     

       2059
       2059
       -
       	// all spindles that the repo owner is a member of

     

       2060
       2060
       -
       	spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid())

     

       2061
       2061
       -
       	if err != nil {

     

       2062
       2062
       -
       		l.Error("failed to fetch spindles", "err", err)

     

       2063
       2063
       -
       		return

     

       2064
       2064
       -
       	}

     

       2065
       2065
       -
       

     

       2066
       2066
       -
       	var secrets []*tangled.RepoListSecrets_Secret

     

       2067
       2067
       -
       	if f.Spindle != "" {

     

       2068
       2068
       -
       		if spindleClient, err := rp.oauth.ServiceClient(

     

       2069
       2069
       -
       			r,

     

       2070
       2070
       -
       			oauth.WithService(f.Spindle),

     

       2071
       2071
       -
       			oauth.WithLxm(tangled.RepoListSecretsNSID),

     

       2072
       2072
       -
       			oauth.WithExp(60),

     

       2073
       2073
       -
       			oauth.WithDev(rp.config.Core.Dev),

     

       2074
       2074
       -
       		); err != nil {

     

       2075
       2075
       -
       			l.Error("failed to create spindle client", "err", err)

     

       2076
       2076
       -
       		} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {

     

       2077
       2077
       -
       			l.Error("failed to fetch secrets", "err", err)

     

       2078
       2078
       -
       		} else {

     

       2079
       2079
       -
       			secrets = resp.Secrets

     

       2080
       2080
       -
       		}

     

       2081
       2081
       -
       	}

     

       2082
       2082
       -
       

     

       2083
       2083
       -
       	slices.SortFunc(secrets, func(a, b *tangled.RepoListSecrets_Secret) int {

     

       2084
       2084
       -
       		return strings.Compare(a.Key, b.Key)

     

       2085
       2085
       -
       	})

     

       2086
       2086
       -
       

     

       2087
       2087
       -
       	var dids []string

     

       2088
       2088
       -
       	for _, s := range secrets {

     

       2089
       2089
       -
       		dids = append(dids, s.CreatedBy)

     

       2090
       2090
       -
       	}

     

       2091
       2091
       -
       	resolvedIdents := rp.idResolver.ResolveIdents(r.Context(), dids)

     

       2092
       2092
       -
       

     

       2093
       2093
       -
       	// convert to a more manageable form

     

       2094
       2094
       -
       	var niceSecret []map[string]any

     

       2095
       2095
       -
       	for id, s := range secrets {

     

       2096
       2096
       -
       		when, _ := time.Parse(time.RFC3339, s.CreatedAt)

     

       2097
       2097
       -
       		niceSecret = append(niceSecret, map[string]any{

     

       2098
       2098
       -
       			"Id":        id,

     

       2099
       2099
       -
       			"Key":       s.Key,

     

       2100
       2100
       -
       			"CreatedAt": when,

     

       2101
       2101
       -
       			"CreatedBy": resolvedIdents[id].Handle.String(),

     

       2102
       2102
       -
       		})

     

       2103
       2103
       -
       	}

     

       2104
       2104
       -
       

     

       2105
       2105
       -
       	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       2106
       2106
       -
       		LoggedInUser:   user,

     

       2107
       2107
       -
       		RepoInfo:       f.RepoInfo(user),

     

       2108
       2108
       -
       		Tabs:           settingsTabs,

     

       2109
       2109
       -
       		Tab:            "pipelines",

     

       2110
       2110
       -
       		Spindles:       spindles,

     

       2111
       2111
       -
       		CurrentSpindle: f.Spindle,

     

       2112
       2112
       -
       		Secrets:        niceSecret,

     

       2113
       2113
       -
       	})

     

       934
       934
       +
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.Did))

     

       2114
       935
        
       }

     

       2115
       936
        
       

     

       2116
       937
        
       func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {

     
···

       2139
       960
        
       			return

     

       2140
       961
        
       		}

     

       2141
       962
        
       

     

       2142
       2142
       -
       		repoInfo := f.RepoInfo(user)

     

       2143
       2143
       -
       		if repoInfo.Source == nil {

     

       963
       963
       +
       		if f.Source == "" {

     

       2144
       964
        
       			rp.pages.Notice(w, "repo", "This repository is not a fork.")

     

       2145
       965
        
       			return

     

       2146
       966
        
       		}

     
···

       2151
       971
        
       			&tangled.RepoForkSync_Input{

     

       2152
       972
        
       				Did:    user.Did,

     

       2153
       973
        
       				Name:   f.Name,

     

       2154
       2154
       -
       				Source: repoInfo.Source.RepoAt().String(),

     

       974
       974
       +
       				Source: f.Source,

     

       2155
       975
        
       				Branch: ref,

     

       2156
       976
        
       			},

     

       2157
       977
        
       		)

     
···

       2187
       1007
        
       		rp.pages.ForkRepo(w, pages.ForkRepoParams{

     

       2188
       1008
        
       			LoggedInUser: user,

     

       2189
       1009
        
       			Knots:        knots,

     

       2190
       2190
       -
       			RepoInfo:     f.RepoInfo(user),

     

       1010
       1010
       +
       			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       2191
       1011
        
       		})

     

       2192
       1012
        
       

     

       2193
       1013
        
       	case http.MethodPost:

     
···

       2217
       1037
        
       		// in the user's account.

     

       2218
       1038
        
       		existingRepo, err := db.GetRepo(

     

       2219
       1039
        
       			rp.db,

     

       2220
       2220
       -
       			db.FilterEq("did", user.Did),

     

       2221
       2221
       -
       			db.FilterEq("name", forkName),

     

       1040
       1040
       +
       			orm.FilterEq("did", user.Did),

     

       1041
       1041
       +
       			orm.FilterEq("name", forkName),

     

       2222
       1042
        
       		)

     

       2223
       1043
        
       		if err != nil {

     

       2224
       1044
        
       			if !errors.Is(err, sql.ErrNoRows) {

     
···

       2238
       1058
        
       			uri = "http"

     

       2239
       1059
        
       		}

     

       2240
       1060
        
       

     

       2241
       2241
       -
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)

     

       1061
       1061
       +
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)

     

       2242
       1062
        
       		l = l.With("cloneUrl", forkSourceUrl)

     

       2243
       1063
        
       

     

       2244
       1064
        
       		sourceAt := f.RepoAt().String()

     
···

       2251
       1071
        
       			Knot:        targetKnot,

     

       2252
       1072
        
       			Rkey:        rkey,

     

       2253
       1073
        
       			Source:      sourceAt,

     

       2254
       2254
       -
       			Description: f.Repo.Description,

     

       1074
       1074
       +
       			Description: f.Description,

     

       2255
       1075
        
       			Created:     time.Now(),

     

       2256
       2256
       -
       			Labels:      models.DefaultLabelDefs(),

     

       1076
       1076
       +
       			Labels:      rp.config.Label.DefaultLabelDefs,

     

       2257
       1077
        
       		}

     

       2258
       1078
        
       		record := repo.AsRecord()

     

       2259
       1079
        
       

     
···

       2310
       1130
        
       		}

     

       2311
       1131
        
       		defer rollback()

     

       2312
       1132
        
       

     

       1133
       1133
       +
       		// TODO: this could coordinate better with the knot to recieve a clone status

     

       2313
       1134
        
       		client, err := rp.oauth.ServiceClient(

     

       2314
       1135
        
       			r,

     

       2315
       1136
        
       			oauth.WithService(targetKnot),

     

       2316
       1137
        
       			oauth.WithLxm(tangled.RepoCreateNSID),

     

       2317
       1138
        
       			oauth.WithDev(rp.config.Core.Dev),

     

       1139
       1139
       +
       			oauth.WithTimeout(time.Second*20), // big repos take time to clone

     

       2318
       1140
        
       		)

     

       2319
       1141
        
       		if err != nil {

     

       2320
       1142
        
       			l.Error("could not create service client", "err", err)

     
···

       2369
       1191
        
       		aturi = ""

     

       2370
       1192
        
       

     

       2371
       1193
        
       		rp.notifier.NewRepo(r.Context(), repo)

     

       2372
       2372
       -
       		rp.pages.HxLocation(w, fmt.Sprintf("/@%s/%s", user.Did, forkName))

     

       1194
       1194
       +
       		rp.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, forkName))

     

       2373
       1195
        
       	}

     

       2374
       1196
        
       }

     

       2375
       1197
        
       

     
···

       2394
       1216
        
       	})

     

       2395
       1217
        
       	return err

     

       2396
       1218
        
       }

     

       2397
       2397
       -
       

     

       2398
       2398
       -
       func (rp *Repo) RepoCompareNew(w http.ResponseWriter, r *http.Request) {

     

       2399
       2399
       -
       	l := rp.logger.With("handler", "RepoCompareNew")

     

       2400
       2400
       -
       

     

       2401
       2401
       -
       	user := rp.oauth.GetUser(r)

     

       2402
       2402
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       2403
       2403
       -
       	if err != nil {

     

       2404
       2404
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       2405
       2405
       -
       		return

     

       2406
       2406
       -
       	}

     

       2407
       2407
       -
       

     

       2408
       2408
       -
       	scheme := "http"

     

       2409
       2409
       -
       	if !rp.config.Core.Dev {

     

       2410
       2410
       -
       		scheme = "https"

     

       2411
       2411
       -
       	}

     

       2412
       2412
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       2413
       2413
       -
       	xrpcc := &indigoxrpc.Client{

     

       2414
       2414
       -
       		Host: host,

     

       2415
       2415
       -
       	}

     

       2416
       2416
       -
       

     

       2417
       2417
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       2418
       2418
       -
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2419
       2419
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2420
       2420
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2421
       2421
       -
       		rp.pages.Error503(w)

     

       2422
       2422
       -
       		return

     

       2423
       2423
       -
       	}

     

       2424
       2424
       -
       

     

       2425
       2425
       -
       	var branchResult types.RepoBranchesResponse

     

       2426
       2426
       -
       	if err := json.Unmarshal(branchBytes, &branchResult); err != nil {

     

       2427
       2427
       -
       		l.Error("failed to decode XRPC branches response", "err", err)

     

       2428
       2428
       -
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       2429
       2429
       -
       		return

     

       2430
       2430
       -
       	}

     

       2431
       2431
       -
       	branches := branchResult.Branches

     

       2432
       2432
       -
       

     

       2433
       2433
       -
       	sortBranches(branches)

     

       2434
       2434
       -
       

     

       2435
       2435
       -
       	var defaultBranch string

     

       2436
       2436
       -
       	for _, b := range branches {

     

       2437
       2437
       -
       		if b.IsDefault {

     

       2438
       2438
       -
       			defaultBranch = b.Name

     

       2439
       2439
       -
       		}

     

       2440
       2440
       -
       	}

     

       2441
       2441
       -
       

     

       2442
       2442
       -
       	base := defaultBranch

     

       2443
       2443
       -
       	head := defaultBranch

     

       2444
       2444
       -
       

     

       2445
       2445
       -
       	params := r.URL.Query()

     

       2446
       2446
       -
       	queryBase := params.Get("base")

     

       2447
       2447
       -
       	queryHead := params.Get("head")

     

       2448
       2448
       -
       	if queryBase != "" {

     

       2449
       2449
       -
       		base = queryBase

     

       2450
       2450
       -
       	}

     

       2451
       2451
       -
       	if queryHead != "" {

     

       2452
       2452
       -
       		head = queryHead

     

       2453
       2453
       -
       	}

     

       2454
       2454
       -
       

     

       2455
       2455
       -
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2456
       2456
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2457
       2457
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2458
       2458
       -
       		rp.pages.Error503(w)

     

       2459
       2459
       -
       		return

     

       2460
       2460
       -
       	}

     

       2461
       2461
       -
       

     

       2462
       2462
       -
       	var tags types.RepoTagsResponse

     

       2463
       2463
       -
       	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       2464
       2464
       -
       		l.Error("failed to decode XRPC tags response", "err", err)

     

       2465
       2465
       -
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       2466
       2466
       -
       		return

     

       2467
       2467
       -
       	}

     

       2468
       2468
       -
       

     

       2469
       2469
       -
       	repoinfo := f.RepoInfo(user)

     

       2470
       2470
       -
       

     

       2471
       2471
       -
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       2472
       2472
       -
       		LoggedInUser: user,

     

       2473
       2473
       -
       		RepoInfo:     repoinfo,

     

       2474
       2474
       -
       		Branches:     branches,

     

       2475
       2475
       -
       		Tags:         tags.Tags,

     

       2476
       2476
       -
       		Base:         base,

     

       2477
       2477
       -
       		Head:         head,

     

       2478
       2478
       -
       	})

     

       2479
       2479
       -
       }

     

       2480
       2480
       -
       

     

       2481
       2481
       -
       func (rp *Repo) RepoCompare(w http.ResponseWriter, r *http.Request) {

     

       2482
       2482
       -
       	l := rp.logger.With("handler", "RepoCompare")

     

       2483
       2483
       -
       

     

       2484
       2484
       -
       	user := rp.oauth.GetUser(r)

     

       2485
       2485
       -
       	f, err := rp.repoResolver.Resolve(r)

     

       2486
       2486
       -
       	if err != nil {

     

       2487
       2487
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       2488
       2488
       -
       		return

     

       2489
       2489
       -
       	}

     

       2490
       2490
       -
       

     

       2491
       2491
       -
       	var diffOpts types.DiffOpts

     

       2492
       2492
       -
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       2493
       2493
       -
       		diffOpts.Split = true

     

       2494
       2494
       -
       	}

     

       2495
       2495
       -
       

     

       2496
       2496
       -
       	// if user is navigating to one of

     

       2497
       2497
       -
       	//   /compare/{base}/{head}

     

       2498
       2498
       -
       	//   /compare/{base}...{head}

     

       2499
       2499
       -
       	base := chi.URLParam(r, "base")

     

       2500
       2500
       -
       	head := chi.URLParam(r, "head")

     

       2501
       2501
       -
       	if base == "" && head == "" {

     

       2502
       2502
       -
       		rest := chi.URLParam(r, "*") // master...feature/xyz

     

       2503
       2503
       -
       		parts := strings.SplitN(rest, "...", 2)

     

       2504
       2504
       -
       		if len(parts) == 2 {

     

       2505
       2505
       -
       			base = parts[0]

     

       2506
       2506
       -
       			head = parts[1]

     

       2507
       2507
       -
       		}

     

       2508
       2508
       -
       	}

     

       2509
       2509
       -
       

     

       2510
       2510
       -
       	base, _ = url.PathUnescape(base)

     

       2511
       2511
       -
       	head, _ = url.PathUnescape(head)

     

       2512
       2512
       -
       

     

       2513
       2513
       -
       	if base == "" || head == "" {

     

       2514
       2514
       -
       		l.Error("invalid comparison")

     

       2515
       2515
       -
       		rp.pages.Error404(w)

     

       2516
       2516
       -
       		return

     

       2517
       2517
       -
       	}

     

       2518
       2518
       -
       

     

       2519
       2519
       -
       	scheme := "http"

     

       2520
       2520
       -
       	if !rp.config.Core.Dev {

     

       2521
       2521
       -
       		scheme = "https"

     

       2522
       2522
       -
       	}

     

       2523
       2523
       -
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       2524
       2524
       -
       	xrpcc := &indigoxrpc.Client{

     

       2525
       2525
       -
       		Host: host,

     

       2526
       2526
       -
       	}

     

       2527
       2527
       -
       

     

       2528
       2528
       -
       	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       2529
       2529
       -
       

     

       2530
       2530
       -
       	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       2531
       2531
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2532
       2532
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2533
       2533
       -
       		rp.pages.Error503(w)

     

       2534
       2534
       -
       		return

     

       2535
       2535
       -
       	}

     

       2536
       2536
       -
       

     

       2537
       2537
       -
       	var branches types.RepoBranchesResponse

     

       2538
       2538
       -
       	if err := json.Unmarshal(branchBytes, &branches); err != nil {

     

       2539
       2539
       -
       		l.Error("failed to decode XRPC branches response", "err", err)

     

       2540
       2540
       -
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       2541
       2541
       -
       		return

     

       2542
       2542
       -
       	}

     

       2543
       2543
       -
       

     

       2544
       2544
       -
       	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       2545
       2545
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2546
       2546
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2547
       2547
       -
       		rp.pages.Error503(w)

     

       2548
       2548
       -
       		return

     

       2549
       2549
       -
       	}

     

       2550
       2550
       -
       

     

       2551
       2551
       -
       	var tags types.RepoTagsResponse

     

       2552
       2552
       -
       	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       2553
       2553
       -
       		l.Error("failed to decode XRPC tags response", "err", err)

     

       2554
       2554
       -
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       2555
       2555
       -
       		return

     

       2556
       2556
       -
       	}

     

       2557
       2557
       -
       

     

       2558
       2558
       -
       	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       2559
       2559
       -
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       2560
       2560
       -
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       2561
       2561
       -
       		rp.pages.Error503(w)

     

       2562
       2562
       -
       		return

     

       2563
       2563
       -
       	}

     

       2564
       2564
       -
       

     

       2565
       2565
       -
       	var formatPatch types.RepoFormatPatchResponse

     

       2566
       2566
       -
       	if err := json.Unmarshal(compareBytes, &formatPatch); err != nil {

     

       2567
       2567
       -
       		l.Error("failed to decode XRPC compare response", "err", err)

     

       2568
       2568
       -
       		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       2569
       2569
       -
       		return

     

       2570
       2570
       -
       	}

     

       2571
       2571
       -
       

     

       2572
       2572
       -
       	var diff types.NiceDiff

     

       2573
       2573
       -
       	if formatPatch.CombinedPatchRaw != "" {

     

       2574
       2574
       -
       		diff = patchutil.AsNiceDiff(formatPatch.CombinedPatchRaw, base)

     

       2575
       2575
       -
       	} else {

     

       2576
       2576
       -
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       2577
       2577
       -
       	}

     

       2578
       2578
       -
       

     

       2579
       2579
       -
       	repoinfo := f.RepoInfo(user)

     

       2580
       2580
       -
       

     

       2581
       2581
       -
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       2582
       2582
       -
       		LoggedInUser: user,

     

       2583
       2583
       -
       		RepoInfo:     repoinfo,

     

       2584
       2584
       -
       		Branches:     branches.Branches,

     

       2585
       2585
       -
       		Tags:         tags.Tags,

     

       2586
       2586
       -
       		Base:         base,

     

       2587
       2587
       -
       		Head:         head,

     

       2588
       2588
       -
       		Diff:         &diff,

     

       2589
       2589
       -
       		DiffOpts:     diffOpts,

     

       2590
       2590
       -
       	})

     

       2591
       2591
       -
       

     

       2592
       2592
       -
       }

+20 -70

appview/repo/repo_util.go

···

       1
       1
        
       package repo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"crypto/rand"

     

       6
       6
       -
       	"fmt"

     

       7
       7
       -
       	"math/big"

     

       4
       4
       +
       	"maps"

     

       8
       5
        
       	"slices"

     

       9
       6
        
       	"sort"

     

       10
       7
        
       	"strings"

     

       11
       8
        
       

     

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

     

       13
       10
        
       	"tangled.org/core/appview/models"

     

       14
       14
       -
       	"tangled.org/core/appview/pages/repoinfo"

     

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

     

       15
       12
        
       	"tangled.org/core/types"

     

       16
       16
       -
       

     

       17
       17
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       18
       13
        
       )

     

       19
       14
        
       

     

       20
       15
        
       func sortFiles(files []types.NiceTree) {

     

       21
       16
        
       	sort.Slice(files, func(i, j int) bool {

     

       22
       22
       -
       		iIsFile := files[i].IsFile

     

       23
       23
       -
       		jIsFile := files[j].IsFile

     

       17
       17
       +
       		iIsFile := files[i].IsFile()

     

       18
       18
       +
       		jIsFile := files[j].IsFile()

     

       24
       19
        
       		if iIsFile != jIsFile {

     

       25
       20
        
       			return !iIsFile

     

       26
       21
        
       		}

     
···

       47
       42
        
       	})

     

       48
       43
        
       }

     

       49
       44
        
       

     

       50
       50
       -
       func uniqueEmails(commits []*object.Commit) []string {

     

       45
       45
       +
       func uniqueEmails(commits []types.Commit) []string {

     

       51
       46
        
       	emails := make(map[string]struct{})

     

       52
       47
        
       	for _, commit := range commits {

     

       53
       53
       -
       		if commit.Author.Email != "" {

     

       54
       54
       -
       			emails[commit.Author.Email] = struct{}{}

     

       55
       55
       -
       		}

     

       56
       56
       -
       		if commit.Committer.Email != "" {

     

       57
       57
       -
       			emails[commit.Committer.Email] = struct{}{}

     

       48
       48
       +
       		emails[commit.Author.Email] = struct{}{}

     

       49
       49
       +
       		emails[commit.Committer.Email] = struct{}{}

     

       50
       50
       +
       		for _, c := range commit.CoAuthors() {

     

       51
       51
       +
       			emails[c.Email] = struct{}{}

     

       58
       52
        
       		}

     

       59
       53
        
       	}

     

       60
       60
       -
       	var uniqueEmails []string

     

       61
       61
       -
       	for email := range emails {

     

       62
       62
       -
       		uniqueEmails = append(uniqueEmails, email)

     

       63
       63
       -
       	}

     

       64
       64
       -
       	return uniqueEmails

     

       54
       54
       +
       

     

       55
       55
       +
       	// delete empty emails if any, from the set

     

       56
       56
       +
       	delete(emails, "")

     

       57
       57
       +
       

     

       58
       58
       +
       	return slices.Collect(maps.Keys(emails))

     

       65
       59
        
       }

     

       66
       60
        
       

     

       67
       61
        
       func balanceIndexItems(commitCount, branchCount, tagCount, fileCount int) (commitsTrunc int, branchesTrunc int, tagsTrunc int) {

     
···

       92
       86
        
       	return

     

       93
       87
        
       }

     

       94
       88
        
       

     

       95
       95
       -
       // emailToDidOrHandle takes an emailToDidMap from db.GetEmailToDid

     

       96
       96
       -
       // and resolves all dids to handles and returns a new map[string]string

     

       97
       97
       -
       func emailToDidOrHandle(r *Repo, emailToDidMap map[string]string) map[string]string {

     

       98
       98
       -
       	if emailToDidMap == nil {

     

       99
       99
       -
       		return nil

     

       100
       100
       -
       	}

     

       101
       101
       -
       

     

       102
       102
       -
       	var dids []string

     

       103
       103
       -
       	for _, v := range emailToDidMap {

     

       104
       104
       -
       		dids = append(dids, v)

     

       105
       105
       -
       	}

     

       106
       106
       -
       	resolvedIdents := r.idResolver.ResolveIdents(context.Background(), dids)

     

       107
       107
       -
       

     

       108
       108
       -
       	didHandleMap := make(map[string]string)

     

       109
       109
       -
       	for _, identity := range resolvedIdents {

     

       110
       110
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       111
       111
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       112
       112
       -
       		} else {

     

       113
       113
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       114
       114
       -
       		}

     

       115
       115
       -
       	}

     

       116
       116
       -
       

     

       117
       117
       -
       	// Create map of email to didOrHandle for commit display

     

       118
       118
       -
       	emailToDidOrHandle := make(map[string]string)

     

       119
       119
       -
       	for email, did := range emailToDidMap {

     

       120
       120
       -
       		if didOrHandle, ok := didHandleMap[did]; ok {

     

       121
       121
       -
       			emailToDidOrHandle[email] = didOrHandle

     

       122
       122
       -
       		}

     

       123
       123
       -
       	}

     

       124
       124
       -
       

     

       125
       125
       -
       	return emailToDidOrHandle

     

       126
       126
       -
       }

     

       127
       127
       -
       

     

       128
       128
       -
       func randomString(n int) string {

     

       129
       129
       -
       	const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

     

       130
       130
       -
       	result := make([]byte, n)

     

       131
       131
       -
       

     

       132
       132
       -
       	for i := 0; i < n; i++ {

     

       133
       133
       -
       		n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))

     

       134
       134
       -
       		result[i] = letters[n.Int64()]

     

       135
       135
       -
       	}

     

       136
       136
       -
       

     

       137
       137
       -
       	return string(result)

     

       138
       138
       -
       }

     

       139
       139
       -
       

     

       140
       89
        
       // grab pipelines from DB and munge that into a hashmap with commit sha as key

     

       141
       90
        
       //

     

       142
       91
        
       // golang is so blessed that it requires 35 lines of imperative code for this

     

       143
       92
        
       func getPipelineStatuses(

     

       144
       93
        
       	d *db.DB,

     

       145
       145
       -
       	repoInfo repoinfo.RepoInfo,

     

       94
       94
       +
       	repo *models.Repo,

     

       146
       95
        
       	shas []string,

     

       147
       96
        
       ) (map[string]models.Pipeline, error) {

     

       148
       97
        
       	m := make(map[string]models.Pipeline)

     
···

       153
       102
        
       

     

       154
       103
        
       	ps, err := db.GetPipelineStatuses(

     

       155
       104
        
       		d,

     

       156
       156
       -
       		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       157
       157
       -
       		db.FilterEq("repo_name", repoInfo.Name),

     

       158
       158
       -
       		db.FilterEq("knot", repoInfo.Knot),

     

       159
       159
       -
       		db.FilterIn("sha", shas),

     

       105
       105
       +
       		len(shas),

     

       106
       106
       +
       		orm.FilterEq("repo_owner", repo.Did),

     

       107
       107
       +
       		orm.FilterEq("repo_name", repo.Name),

     

       108
       108
       +
       		orm.FilterEq("knot", repo.Knot),

     

       109
       109
       +
       		orm.FilterIn("sha", shas),

     

       160
       110
        
       	)

     

       161
       111
        
       	if err != nil {

     

       162
       112
        
       		return nil, err

+14 -20

appview/repo/router.go

···

       9
       9
        
       

     

       10
       10
        
       func (rp *Repo) Router(mw *middleware.Middleware) http.Handler {

     

       11
       11
        
       	r := chi.NewRouter()

     

       12
       12
       -
       	r.Get("/", rp.RepoIndex)

     

       13
       13
       -
       	r.Get("/opengraph", rp.RepoOpenGraphSummary)

     

       14
       14
       -
       	r.Get("/feed.atom", rp.RepoAtomFeed)

     

       15
       15
       -
       	r.Get("/commits/{ref}", rp.RepoLog)

     

       12
       12
       +
       	r.Get("/", rp.Index)

     

       13
       13
       +
       	r.Get("/opengraph", rp.Opengraph)

     

       14
       14
       +
       	r.Get("/feed.atom", rp.AtomFeed)

     

       15
       15
       +
       	r.Get("/commits/{ref}", rp.Log)

     

       16
       16
        
       	r.Route("/tree/{ref}", func(r chi.Router) {

     

       17
       17
       -
       		r.Get("/", rp.RepoIndex)

     

       18
       18
       -
       		r.Get("/*", rp.RepoTree)

     

       17
       17
       +
       		r.Get("/", rp.Index)

     

       18
       18
       +
       		r.Get("/*", rp.Tree)

     

       19
       19
        
       	})

     

       20
       20
       -
       	r.Get("/commit/{ref}", rp.RepoCommit)

     

       21
       21
       -
       	r.Get("/branches", rp.RepoBranches)

     

       20
       20
       +
       	r.Get("/commit/{ref}", rp.Commit)

     

       21
       21
       +
       	r.Get("/branches", rp.Branches)

     

       22
       22
        
       	r.Delete("/branches", rp.DeleteBranch)

     

       23
       23
        
       	r.Route("/tags", func(r chi.Router) {

     

       24
       24
       -
       		r.Get("/", rp.RepoTags)

     

       24
       24
       +
       		r.Get("/", rp.Tags)

     

       25
       25
        
       		r.Route("/{tag}", func(r chi.Router) {

     

       26
       26
        
       			r.Get("/download/{file}", rp.DownloadArtifact)

     

       27
       27
        
       

     
···

       37
       37
        
       			})

     

       38
       38
        
       		})

     

       39
       39
        
       	})

     

       40
       40
       -
       	r.Get("/blob/{ref}/*", rp.RepoBlob)

     

       40
       40
       +
       	r.Get("/blob/{ref}/*", rp.Blob)

     

       41
       41
        
       	r.Get("/raw/{ref}/*", rp.RepoBlobRaw)

     

       42
       42
        
       

     

       43
       43
        
       	// intentionally doesn't use /* as this isn't

     
···

       54
       54
        
       	})

     

       55
       55
        
       

     

       56
       56
        
       	r.Route("/compare", func(r chi.Router) {

     

       57
       57
       -
       		r.Get("/", rp.RepoCompareNew) // start an new comparison

     

       57
       57
       +
       		r.Get("/", rp.CompareNew) // start an new comparison

     

       58
       58
        
       

     

       59
       59
        
       		// we have to wildcard here since we want to support GitHub's compare syntax

     

       60
       60
        
       		//   /compare/{ref1}...{ref2}

     

       61
       61
        
       		// for example:

     

       62
       62
        
       		//   /compare/master...some/feature

     

       63
       63
        
       		//   /compare/master...example.com:another/feature <- this is a fork

     

       64
       64
       -
       		r.Get("/{base}/{head}", rp.RepoCompare)

     

       65
       65
       -
       		r.Get("/*", rp.RepoCompare)

     

       64
       64
       +
       		r.Get("/*", rp.Compare)

     

       66
       65
        
       	})

     

       67
       66
        
       

     

       68
       67
        
       	// label panel in issues/pulls/discussions/tasks

     
···

       74
       73
        
       	// settings routes, needs auth

     

       75
       74
        
       	r.Group(func(r chi.Router) {

     

       76
       75
        
       		r.Use(middleware.AuthMiddleware(rp.oauth))

     

       77
       77
       -
       		// repo description can only be edited by owner

     

       78
       78
       -
       		r.With(mw.RepoPermissionMiddleware("repo:owner")).Route("/description", func(r chi.Router) {

     

       79
       79
       -
       			r.Put("/", rp.RepoDescription)

     

       80
       80
       -
       			r.Get("/", rp.RepoDescription)

     

       81
       81
       -
       			r.Get("/edit", rp.RepoDescriptionEdit)

     

       82
       82
       -
       		})

     

       83
       76
        
       		r.With(mw.RepoPermissionMiddleware("repo:settings")).Route("/settings", func(r chi.Router) {

     

       84
       84
       -
       			r.Get("/", rp.RepoSettings)

     

       77
       77
       +
       			r.Get("/", rp.Settings)

     

       78
       78
       +
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/base", rp.EditBaseSettings)

     

       85
       79
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Post("/spindle", rp.EditSpindle)

     

       86
       80
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/label", rp.AddLabelDef)

     

       87
       81
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Delete("/label", rp.DeleteLabelDef)

+471

appview/repo/settings.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"slices"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       	"time"

     

       10
       10
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       17
       17
       +
       	"tangled.org/core/orm"

     

       18
       18
       +
       	"tangled.org/core/types"

     

       19
       19
       +
       

     

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

     

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

     

       22
       22
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       23
       23
       +
       )

     

       24
       24
       +
       

     

       25
       25
       +
       type tab = map[string]any

     

       26
       26
       +
       

     

       27
       27
       +
       var (

     

       28
       28
       +
       	// would be great to have ordered maps right about now

     

       29
       29
       +
       	settingsTabs []tab = []tab{

     

       30
       30
       +
       		{"Name": "general", "Icon": "sliders-horizontal"},

     

       31
       31
       +
       		{"Name": "access", "Icon": "users"},

     

       32
       32
       +
       		{"Name": "pipelines", "Icon": "layers-2"},

     

       33
       33
       +
       	}

     

       34
       34
       +
       )

     

       35
       35
       +
       

     

       36
       36
       +
       func (rp *Repo) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       37
       37
       +
       	l := rp.logger.With("handler", "SetDefaultBranch")

     

       38
       38
       +
       

     

       39
       39
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       40
       40
       +
       	if err != nil {

     

       41
       41
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       42
       42
       +
       		return

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	noticeId := "operation-error"

     

       46
       46
       +
       	branch := r.FormValue("branch")

     

       47
       47
       +
       	if branch == "" {

     

       48
       48
       +
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       49
       49
       +
       		return

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	client, err := rp.oauth.ServiceClient(

     

       53
       53
       +
       		r,

     

       54
       54
       +
       		oauth.WithService(f.Knot),

     

       55
       55
       +
       		oauth.WithLxm(tangled.RepoSetDefaultBranchNSID),

     

       56
       56
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       57
       57
       +
       	)

     

       58
       58
       +
       	if err != nil {

     

       59
       59
       +
       		l.Error("failed to connect to knot server", "err", err)

     

       60
       60
       +
       		rp.pages.Notice(w, noticeId, "Failed to connect to knot server.")

     

       61
       61
       +
       		return

     

       62
       62
       +
       	}

     

       63
       63
       +
       

     

       64
       64
       +
       	xe := tangled.RepoSetDefaultBranch(

     

       65
       65
       +
       		r.Context(),

     

       66
       66
       +
       		client,

     

       67
       67
       +
       		&tangled.RepoSetDefaultBranch_Input{

     

       68
       68
       +
       			Repo:          f.RepoAt().String(),

     

       69
       69
       +
       			DefaultBranch: branch,

     

       70
       70
       +
       		},

     

       71
       71
       +
       	)

     

       72
       72
       +
       	if err := xrpcclient.HandleXrpcErr(xe); err != nil {

     

       73
       73
       +
       		l.Error("xrpc failed", "err", xe)

     

       74
       74
       +
       		rp.pages.Notice(w, noticeId, err.Error())

     

       75
       75
       +
       		return

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	rp.pages.HxRefresh(w)

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       81
       81
       +
       func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {

     

       82
       82
       +
       	user := rp.oauth.GetUser(r)

     

       83
       83
       +
       	l := rp.logger.With("handler", "Secrets")

     

       84
       84
       +
       	l = l.With("did", user.Did)

     

       85
       85
       +
       

     

       86
       86
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       89
       89
       +
       		return

     

       90
       90
       +
       	}

     

       91
       91
       +
       

     

       92
       92
       +
       	if f.Spindle == "" {

     

       93
       93
       +
       		l.Error("empty spindle cannot add/rm secret", "err", err)

     

       94
       94
       +
       		return

     

       95
       95
       +
       	}

     

       96
       96
       +
       

     

       97
       97
       +
       	lxm := tangled.RepoAddSecretNSID

     

       98
       98
       +
       	if r.Method == http.MethodDelete {

     

       99
       99
       +
       		lxm = tangled.RepoRemoveSecretNSID

     

       100
       100
       +
       	}

     

       101
       101
       +
       

     

       102
       102
       +
       	spindleClient, err := rp.oauth.ServiceClient(

     

       103
       103
       +
       		r,

     

       104
       104
       +
       		oauth.WithService(f.Spindle),

     

       105
       105
       +
       		oauth.WithLxm(lxm),

     

       106
       106
       +
       		oauth.WithExp(60),

     

       107
       107
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       108
       108
       +
       	)

     

       109
       109
       +
       	if err != nil {

     

       110
       110
       +
       		l.Error("failed to create spindle client", "err", err)

     

       111
       111
       +
       		return

     

       112
       112
       +
       	}

     

       113
       113
       +
       

     

       114
       114
       +
       	key := r.FormValue("key")

     

       115
       115
       +
       	if key == "" {

     

       116
       116
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       117
       117
       +
       		return

     

       118
       118
       +
       	}

     

       119
       119
       +
       

     

       120
       120
       +
       	switch r.Method {

     

       121
       121
       +
       	case http.MethodPut:

     

       122
       122
       +
       		errorId := "add-secret-error"

     

       123
       123
       +
       

     

       124
       124
       +
       		value := r.FormValue("value")

     

       125
       125
       +
       		if value == "" {

     

       126
       126
       +
       			w.WriteHeader(http.StatusBadRequest)

     

       127
       127
       +
       			return

     

       128
       128
       +
       		}

     

       129
       129
       +
       

     

       130
       130
       +
       		err = tangled.RepoAddSecret(

     

       131
       131
       +
       			r.Context(),

     

       132
       132
       +
       			spindleClient,

     

       133
       133
       +
       			&tangled.RepoAddSecret_Input{

     

       134
       134
       +
       				Repo:  f.RepoAt().String(),

     

       135
       135
       +
       				Key:   key,

     

       136
       136
       +
       				Value: value,

     

       137
       137
       +
       			},

     

       138
       138
       +
       		)

     

       139
       139
       +
       		if err != nil {

     

       140
       140
       +
       			l.Error("Failed to add secret.", "err", err)

     

       141
       141
       +
       			rp.pages.Notice(w, errorId, "Failed to add secret.")

     

       142
       142
       +
       			return

     

       143
       143
       +
       		}

     

       144
       144
       +
       

     

       145
       145
       +
       	case http.MethodDelete:

     

       146
       146
       +
       		errorId := "operation-error"

     

       147
       147
       +
       

     

       148
       148
       +
       		err = tangled.RepoRemoveSecret(

     

       149
       149
       +
       			r.Context(),

     

       150
       150
       +
       			spindleClient,

     

       151
       151
       +
       			&tangled.RepoRemoveSecret_Input{

     

       152
       152
       +
       				Repo: f.RepoAt().String(),

     

       153
       153
       +
       				Key:  key,

     

       154
       154
       +
       			},

     

       155
       155
       +
       		)

     

       156
       156
       +
       		if err != nil {

     

       157
       157
       +
       			l.Error("Failed to delete secret.", "err", err)

     

       158
       158
       +
       			rp.pages.Notice(w, errorId, "Failed to delete secret.")

     

       159
       159
       +
       			return

     

       160
       160
       +
       		}

     

       161
       161
       +
       	}

     

       162
       162
       +
       

     

       163
       163
       +
       	rp.pages.HxRefresh(w)

     

       164
       164
       +
       }

     

       165
       165
       +
       

     

       166
       166
       +
       func (rp *Repo) Settings(w http.ResponseWriter, r *http.Request) {

     

       167
       167
       +
       	tabVal := r.URL.Query().Get("tab")

     

       168
       168
       +
       	if tabVal == "" {

     

       169
       169
       +
       		tabVal = "general"

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	switch tabVal {

     

       173
       173
       +
       	case "general":

     

       174
       174
       +
       		rp.generalSettings(w, r)

     

       175
       175
       +
       

     

       176
       176
       +
       	case "access":

     

       177
       177
       +
       		rp.accessSettings(w, r)

     

       178
       178
       +
       

     

       179
       179
       +
       	case "pipelines":

     

       180
       180
       +
       		rp.pipelineSettings(w, r)

     

       181
       181
       +
       	}

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) {

     

       185
       185
       +
       	l := rp.logger.With("handler", "generalSettings")

     

       186
       186
       +
       

     

       187
       187
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       188
       188
       +
       	user := rp.oauth.GetUser(r)

     

       189
       189
       +
       

     

       190
       190
       +
       	scheme := "http"

     

       191
       191
       +
       	if !rp.config.Core.Dev {

     

       192
       192
       +
       		scheme = "https"

     

       193
       193
       +
       	}

     

       194
       194
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       195
       195
       +
       	xrpcc := &indigoxrpc.Client{

     

       196
       196
       +
       		Host: host,

     

       197
       197
       +
       	}

     

       198
       198
       +
       

     

       199
       199
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       200
       200
       +
       	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       201
       201
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       202
       202
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       203
       203
       +
       		rp.pages.Error503(w)

     

       204
       204
       +
       		return

     

       205
       205
       +
       	}

     

       206
       206
       +
       

     

       207
       207
       +
       	var result types.RepoBranchesResponse

     

       208
       208
       +
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       209
       209
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       210
       210
       +
       		rp.pages.Error503(w)

     

       211
       211
       +
       		return

     

       212
       212
       +
       	}

     

       213
       213
       +
       

     

       214
       214
       +
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       215
       215
       +
       	if err != nil {

     

       216
       216
       +
       		l.Error("failed to fetch labels", "err", err)

     

       217
       217
       +
       		rp.pages.Error503(w)

     

       218
       218
       +
       		return

     

       219
       219
       +
       	}

     

       220
       220
       +
       

     

       221
       221
       +
       	labels, err := db.GetLabelDefinitions(rp.db, orm.FilterIn("at_uri", f.Labels))

     

       222
       222
       +
       	if err != nil {

     

       223
       223
       +
       		l.Error("failed to fetch labels", "err", err)

     

       224
       224
       +
       		rp.pages.Error503(w)

     

       225
       225
       +
       		return

     

       226
       226
       +
       	}

     

       227
       227
       +
       	// remove default labels from the labels list, if present

     

       228
       228
       +
       	defaultLabelMap := make(map[string]bool)

     

       229
       229
       +
       	for _, dl := range defaultLabels {

     

       230
       230
       +
       		defaultLabelMap[dl.AtUri().String()] = true

     

       231
       231
       +
       	}

     

       232
       232
       +
       	n := 0

     

       233
       233
       +
       	for _, l := range labels {

     

       234
       234
       +
       		if !defaultLabelMap[l.AtUri().String()] {

     

       235
       235
       +
       			labels[n] = l

     

       236
       236
       +
       			n++

     

       237
       237
       +
       		}

     

       238
       238
       +
       	}

     

       239
       239
       +
       	labels = labels[:n]

     

       240
       240
       +
       

     

       241
       241
       +
       	subscribedLabels := make(map[string]struct{})

     

       242
       242
       +
       	for _, l := range f.Labels {

     

       243
       243
       +
       		subscribedLabels[l] = struct{}{}

     

       244
       244
       +
       	}

     

       245
       245
       +
       

     

       246
       246
       +
       	// if there is atleast 1 unsubbed default label, show the "subscribe all" button,

     

       247
       247
       +
       	// if all default labels are subbed, show the "unsubscribe all" button

     

       248
       248
       +
       	shouldSubscribeAll := false

     

       249
       249
       +
       	for _, dl := range defaultLabels {

     

       250
       250
       +
       		if _, ok := subscribedLabels[dl.AtUri().String()]; !ok {

     

       251
       251
       +
       			// one of the default labels is not subscribed to

     

       252
       252
       +
       			shouldSubscribeAll = true

     

       253
       253
       +
       			break

     

       254
       254
       +
       		}

     

       255
       255
       +
       	}

     

       256
       256
       +
       

     

       257
       257
       +
       	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       258
       258
       +
       		LoggedInUser:       user,

     

       259
       259
       +
       		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       260
       260
       +
       		Branches:           result.Branches,

     

       261
       261
       +
       		Labels:             labels,

     

       262
       262
       +
       		DefaultLabels:      defaultLabels,

     

       263
       263
       +
       		SubscribedLabels:   subscribedLabels,

     

       264
       264
       +
       		ShouldSubscribeAll: shouldSubscribeAll,

     

       265
       265
       +
       		Tabs:               settingsTabs,

     

       266
       266
       +
       		Tab:                "general",

     

       267
       267
       +
       	})

     

       268
       268
       +
       }

     

       269
       269
       +
       

     

       270
       270
       +
       func (rp *Repo) accessSettings(w http.ResponseWriter, r *http.Request) {

     

       271
       271
       +
       	l := rp.logger.With("handler", "accessSettings")

     

       272
       272
       +
       

     

       273
       273
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       274
       274
       +
       	user := rp.oauth.GetUser(r)

     

       275
       275
       +
       

     

       276
       276
       +
       	collaborators, err := func(repo *models.Repo) ([]pages.Collaborator, error) {

     

       277
       277
       +
       		repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(repo.DidSlashRepo(), repo.Knot)

     

       278
       278
       +
       		if err != nil {

     

       279
       279
       +
       			return nil, err

     

       280
       280
       +
       		}

     

       281
       281
       +
       		var collaborators []pages.Collaborator

     

       282
       282
       +
       		for _, item := range repoCollaborators {

     

       283
       283
       +
       			// currently only two roles: owner and member

     

       284
       284
       +
       			var role string

     

       285
       285
       +
       			switch item[3] {

     

       286
       286
       +
       			case "repo:owner":

     

       287
       287
       +
       				role = "owner"

     

       288
       288
       +
       			case "repo:collaborator":

     

       289
       289
       +
       				role = "collaborator"

     

       290
       290
       +
       			default:

     

       291
       291
       +
       				continue

     

       292
       292
       +
       			}

     

       293
       293
       +
       

     

       294
       294
       +
       			did := item[0]

     

       295
       295
       +
       

     

       296
       296
       +
       			c := pages.Collaborator{

     

       297
       297
       +
       				Did:  did,

     

       298
       298
       +
       				Role: role,

     

       299
       299
       +
       			}

     

       300
       300
       +
       			collaborators = append(collaborators, c)

     

       301
       301
       +
       		}

     

       302
       302
       +
       		return collaborators, nil

     

       303
       303
       +
       	}(f)

     

       304
       304
       +
       	if err != nil {

     

       305
       305
       +
       		l.Error("failed to get collaborators", "err", err)

     

       306
       306
       +
       	}

     

       307
       307
       +
       

     

       308
       308
       +
       	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       309
       309
       +
       		LoggedInUser:  user,

     

       310
       310
       +
       		RepoInfo:      rp.repoResolver.GetRepoInfo(r, user),

     

       311
       311
       +
       		Tabs:          settingsTabs,

     

       312
       312
       +
       		Tab:           "access",

     

       313
       313
       +
       		Collaborators: collaborators,

     

       314
       314
       +
       	})

     

       315
       315
       +
       }

     

       316
       316
       +
       

     

       317
       317
       +
       func (rp *Repo) pipelineSettings(w http.ResponseWriter, r *http.Request) {

     

       318
       318
       +
       	l := rp.logger.With("handler", "pipelineSettings")

     

       319
       319
       +
       

     

       320
       320
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       321
       321
       +
       	user := rp.oauth.GetUser(r)

     

       322
       322
       +
       

     

       323
       323
       +
       	// all spindles that the repo owner is a member of

     

       324
       324
       +
       	spindles, err := rp.enforcer.GetSpindlesForUser(f.Did)

     

       325
       325
       +
       	if err != nil {

     

       326
       326
       +
       		l.Error("failed to fetch spindles", "err", err)

     

       327
       327
       +
       		return

     

       328
       328
       +
       	}

     

       329
       329
       +
       

     

       330
       330
       +
       	var secrets []*tangled.RepoListSecrets_Secret

     

       331
       331
       +
       	if f.Spindle != "" {

     

       332
       332
       +
       		if spindleClient, err := rp.oauth.ServiceClient(

     

       333
       333
       +
       			r,

     

       334
       334
       +
       			oauth.WithService(f.Spindle),

     

       335
       335
       +
       			oauth.WithLxm(tangled.RepoListSecretsNSID),

     

       336
       336
       +
       			oauth.WithExp(60),

     

       337
       337
       +
       			oauth.WithDev(rp.config.Core.Dev),

     

       338
       338
       +
       		); err != nil {

     

       339
       339
       +
       			l.Error("failed to create spindle client", "err", err)

     

       340
       340
       +
       		} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {

     

       341
       341
       +
       			l.Error("failed to fetch secrets", "err", err)

     

       342
       342
       +
       		} else {

     

       343
       343
       +
       			secrets = resp.Secrets

     

       344
       344
       +
       		}

     

       345
       345
       +
       	}

     

       346
       346
       +
       

     

       347
       347
       +
       	slices.SortFunc(secrets, func(a, b *tangled.RepoListSecrets_Secret) int {

     

       348
       348
       +
       		return strings.Compare(a.Key, b.Key)

     

       349
       349
       +
       	})

     

       350
       350
       +
       

     

       351
       351
       +
       	var dids []string

     

       352
       352
       +
       	for _, s := range secrets {

     

       353
       353
       +
       		dids = append(dids, s.CreatedBy)

     

       354
       354
       +
       	}

     

       355
       355
       +
       	resolvedIdents := rp.idResolver.ResolveIdents(r.Context(), dids)

     

       356
       356
       +
       

     

       357
       357
       +
       	// convert to a more manageable form

     

       358
       358
       +
       	var niceSecret []map[string]any

     

       359
       359
       +
       	for id, s := range secrets {

     

       360
       360
       +
       		when, _ := time.Parse(time.RFC3339, s.CreatedAt)

     

       361
       361
       +
       		niceSecret = append(niceSecret, map[string]any{

     

       362
       362
       +
       			"Id":        id,

     

       363
       363
       +
       			"Key":       s.Key,

     

       364
       364
       +
       			"CreatedAt": when,

     

       365
       365
       +
       			"CreatedBy": resolvedIdents[id].Handle.String(),

     

       366
       366
       +
       		})

     

       367
       367
       +
       	}

     

       368
       368
       +
       

     

       369
       369
       +
       	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       370
       370
       +
       		LoggedInUser:   user,

     

       371
       371
       +
       		RepoInfo:       rp.repoResolver.GetRepoInfo(r, user),

     

       372
       372
       +
       		Tabs:           settingsTabs,

     

       373
       373
       +
       		Tab:            "pipelines",

     

       374
       374
       +
       		Spindles:       spindles,

     

       375
       375
       +
       		CurrentSpindle: f.Spindle,

     

       376
       376
       +
       		Secrets:        niceSecret,

     

       377
       377
       +
       	})

     

       378
       378
       +
       }

     

       379
       379
       +
       

     

       380
       380
       +
       func (rp *Repo) EditBaseSettings(w http.ResponseWriter, r *http.Request) {

     

       381
       381
       +
       	l := rp.logger.With("handler", "EditBaseSettings")

     

       382
       382
       +
       

     

       383
       383
       +
       	noticeId := "repo-base-settings-error"

     

       384
       384
       +
       

     

       385
       385
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       386
       386
       +
       	if err != nil {

     

       387
       387
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       388
       388
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       389
       389
       +
       		return

     

       390
       390
       +
       	}

     

       391
       391
       +
       

     

       392
       392
       +
       	client, err := rp.oauth.AuthorizedClient(r)

     

       393
       393
       +
       	if err != nil {

     

       394
       394
       +
       		l.Error("failed to get client")

     

       395
       395
       +
       		rp.pages.Notice(w, noticeId, "Failed to update repository information, try again later.")

     

       396
       396
       +
       		return

     

       397
       397
       +
       	}

     

       398
       398
       +
       

     

       399
       399
       +
       	var (

     

       400
       400
       +
       		description = r.FormValue("description")

     

       401
       401
       +
       		website     = r.FormValue("website")

     

       402
       402
       +
       		topicStr    = r.FormValue("topics")

     

       403
       403
       +
       	)

     

       404
       404
       +
       

     

       405
       405
       +
       	err = rp.validator.ValidateURI(website)

     

       406
       406
       +
       	if website != "" && err != nil {

     

       407
       407
       +
       		l.Error("invalid uri", "err", err)

     

       408
       408
       +
       		rp.pages.Notice(w, noticeId, err.Error())

     

       409
       409
       +
       		return

     

       410
       410
       +
       	}

     

       411
       411
       +
       

     

       412
       412
       +
       	topics, err := rp.validator.ValidateRepoTopicStr(topicStr)

     

       413
       413
       +
       	if err != nil {

     

       414
       414
       +
       		l.Error("invalid topics", "err", err)

     

       415
       415
       +
       		rp.pages.Notice(w, noticeId, err.Error())

     

       416
       416
       +
       		return

     

       417
       417
       +
       	}

     

       418
       418
       +
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       419
       419
       +
       

     

       420
       420
       +
       	newRepo := *f

     

       421
       421
       +
       	newRepo.Description = description

     

       422
       422
       +
       	newRepo.Website = website

     

       423
       423
       +
       	newRepo.Topics = topics

     

       424
       424
       +
       	record := newRepo.AsRecord()

     

       425
       425
       +
       

     

       426
       426
       +
       	tx, err := rp.db.BeginTx(r.Context(), nil)

     

       427
       427
       +
       	if err != nil {

     

       428
       428
       +
       		l.Error("failed to begin transaction", "err", err)

     

       429
       429
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       430
       430
       +
       		return

     

       431
       431
       +
       	}

     

       432
       432
       +
       	defer tx.Rollback()

     

       433
       433
       +
       

     

       434
       434
       +
       	err = db.PutRepo(tx, newRepo)

     

       435
       435
       +
       	if err != nil {

     

       436
       436
       +
       		l.Error("failed to update repository", "err", err)

     

       437
       437
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       438
       438
       +
       		return

     

       439
       439
       +
       	}

     

       440
       440
       +
       

     

       441
       441
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       442
       442
       +
       	if err != nil {

     

       443
       443
       +
       		// failed to get record

     

       444
       444
       +
       		l.Error("failed to get repo record", "err", err)

     

       445
       445
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, no record found on PDS.")

     

       446
       446
       +
       		return

     

       447
       447
       +
       	}

     

       448
       448
       +
       	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       449
       449
       +
       		Collection: tangled.RepoNSID,

     

       450
       450
       +
       		Repo:       newRepo.Did,

     

       451
       451
       +
       		Rkey:       newRepo.Rkey,

     

       452
       452
       +
       		SwapRecord: ex.Cid,

     

       453
       453
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       454
       454
       +
       			Val: &record,

     

       455
       455
       +
       		},

     

       456
       456
       +
       	})

     

       457
       457
       +
       

     

       458
       458
       +
       	if err != nil {

     

       459
       459
       +
       		l.Error("failed to perferom update-repo query", "err", err)

     

       460
       460
       +
       		// failed to get record

     

       461
       461
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, unable to save to PDS.")

     

       462
       462
       +
       		return

     

       463
       463
       +
       	}

     

       464
       464
       +
       

     

       465
       465
       +
       	err = tx.Commit()

     

       466
       466
       +
       	if err != nil {

     

       467
       467
       +
       		l.Error("failed to commit", "err", err)

     

       468
       468
       +
       	}

     

       469
       469
       +
       

     

       470
       470
       +
       	rp.pages.HxRefresh(w)

     

       471
       471
       +
       }

+80

appview/repo/tags.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       

     

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

     

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

     

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

     

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

     

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

     

       13
       13
       +
       	"tangled.org/core/orm"

     

       14
       14
       +
       	"tangled.org/core/types"

     

       15
       15
       +
       

     

       16
       16
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       17
       17
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) {

     

       21
       21
       +
       	l := rp.logger.With("handler", "RepoTags")

     

       22
       22
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       23
       23
       +
       	if err != nil {

     

       24
       24
       +
       		l.Error("failed to get repo and knot", "err", err)

     

       25
       25
       +
       		return

     

       26
       26
       +
       	}

     

       27
       27
       +
       	scheme := "http"

     

       28
       28
       +
       	if !rp.config.Core.Dev {

     

       29
       29
       +
       		scheme = "https"

     

       30
       30
       +
       	}

     

       31
       31
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       32
       32
       +
       	xrpcc := &indigoxrpc.Client{

     

       33
       33
       +
       		Host: host,

     

       34
       34
       +
       	}

     

       35
       35
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       36
       36
       +
       	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       37
       37
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       38
       38
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       39
       39
       +
       		rp.pages.Error503(w)

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       	var result types.RepoTagsResponse

     

       43
       43
       +
       	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       44
       44
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       45
       45
       +
       		rp.pages.Error503(w)

     

       46
       46
       +
       		return

     

       47
       47
       +
       	}

     

       48
       48
       +
       	artifacts, err := db.GetArtifact(rp.db, orm.FilterEq("repo_at", f.RepoAt()))

     

       49
       49
       +
       	if err != nil {

     

       50
       50
       +
       		l.Error("failed grab artifacts", "err", err)

     

       51
       51
       +
       		return

     

       52
       52
       +
       	}

     

       53
       53
       +
       	// convert artifacts to map for easy UI building

     

       54
       54
       +
       	artifactMap := make(map[plumbing.Hash][]models.Artifact)

     

       55
       55
       +
       	for _, a := range artifacts {

     

       56
       56
       +
       		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       57
       57
       +
       	}

     

       58
       58
       +
       	var danglingArtifacts []models.Artifact

     

       59
       59
       +
       	for _, a := range artifacts {

     

       60
       60
       +
       		found := false

     

       61
       61
       +
       		for _, t := range result.Tags {

     

       62
       62
       +
       			if t.Tag != nil {

     

       63
       63
       +
       				if t.Tag.Hash == a.Tag {

     

       64
       64
       +
       					found = true

     

       65
       65
       +
       				}

     

       66
       66
       +
       			}

     

       67
       67
       +
       		}

     

       68
       68
       +
       		if !found {

     

       69
       69
       +
       			danglingArtifacts = append(danglingArtifacts, a)

     

       70
       70
       +
       		}

     

       71
       71
       +
       	}

     

       72
       72
       +
       	user := rp.oauth.GetUser(r)

     

       73
       73
       +
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       74
       74
       +
       		LoggedInUser:      user,

     

       75
       75
       +
       		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       76
       76
       +
       		RepoTagsResponse:  result,

     

       77
       77
       +
       		ArtifactMap:       artifactMap,

     

       78
       78
       +
       		DanglingArtifacts: danglingArtifacts,

     

       79
       79
       +
       	})

     

       80
       80
       +
       }

+108

appview/repo/tree.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       	"time"

     

       9
       9
       +
       

     

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

     

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

     

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

     

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

     

       14
       14
       +
       	"tangled.org/core/types"

     

       15
       15
       +
       

     

       16
       16
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

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

     

       18
       18
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       19
       19
       +
       )

     

       20
       20
       +
       

     

       21
       21
       +
       func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) {

     

       22
       22
       +
       	l := rp.logger.With("handler", "RepoTree")

     

       23
       23
       +
       	f, err := rp.repoResolver.Resolve(r)

     

       24
       24
       +
       	if err != nil {

     

       25
       25
       +
       		l.Error("failed to fully resolve repo", "err", err)

     

       26
       26
       +
       		return

     

       27
       27
       +
       	}

     

       28
       28
       +
       	ref := chi.URLParam(r, "ref")

     

       29
       29
       +
       	ref, _ = url.PathUnescape(ref)

     

       30
       30
       +
       	// if the tree path has a trailing slash, let's strip it

     

       31
       31
       +
       	// so we don't 404

     

       32
       32
       +
       	treePath := chi.URLParam(r, "*")

     

       33
       33
       +
       	treePath, _ = url.PathUnescape(treePath)

     

       34
       34
       +
       	treePath = strings.TrimSuffix(treePath, "/")

     

       35
       35
       +
       	scheme := "http"

     

       36
       36
       +
       	if !rp.config.Core.Dev {

     

       37
       37
       +
       		scheme = "https"

     

       38
       38
       +
       	}

     

       39
       39
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       40
       40
       +
       	xrpcc := &indigoxrpc.Client{

     

       41
       41
       +
       		Host: host,

     

       42
       42
       +
       	}

     

       43
       43
       +
       	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       44
       44
       +
       	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       45
       45
       +
       	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       46
       46
       +
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       47
       47
       +
       		rp.pages.Error503(w)

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       	// Convert XRPC response to internal types.RepoTreeResponse

     

       51
       51
       +
       	files := make([]types.NiceTree, len(xrpcResp.Files))

     

       52
       52
       +
       	for i, xrpcFile := range xrpcResp.Files {

     

       53
       53
       +
       		file := types.NiceTree{

     

       54
       54
       +
       			Name: xrpcFile.Name,

     

       55
       55
       +
       			Mode: xrpcFile.Mode,

     

       56
       56
       +
       			Size: int64(xrpcFile.Size),

     

       57
       57
       +
       		}

     

       58
       58
       +
       		// Convert last commit info if present

     

       59
       59
       +
       		if xrpcFile.Last_commit != nil {

     

       60
       60
       +
       			commitWhen, _ := time.Parse(time.RFC3339, xrpcFile.Last_commit.When)

     

       61
       61
       +
       			file.LastCommit = &types.LastCommitInfo{

     

       62
       62
       +
       				Hash:    plumbing.NewHash(xrpcFile.Last_commit.Hash),

     

       63
       63
       +
       				Message: xrpcFile.Last_commit.Message,

     

       64
       64
       +
       				When:    commitWhen,

     

       65
       65
       +
       			}

     

       66
       66
       +
       		}

     

       67
       67
       +
       		files[i] = file

     

       68
       68
       +
       	}

     

       69
       69
       +
       	result := types.RepoTreeResponse{

     

       70
       70
       +
       		Ref:   xrpcResp.Ref,

     

       71
       71
       +
       		Files: files,

     

       72
       72
       +
       	}

     

       73
       73
       +
       	if xrpcResp.Parent != nil {

     

       74
       74
       +
       		result.Parent = *xrpcResp.Parent

     

       75
       75
       +
       	}

     

       76
       76
       +
       	if xrpcResp.Dotdot != nil {

     

       77
       77
       +
       		result.DotDot = *xrpcResp.Dotdot

     

       78
       78
       +
       	}

     

       79
       79
       +
       	if xrpcResp.Readme != nil {

     

       80
       80
       +
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       81
       81
       +
       		result.Readme = xrpcResp.Readme.Contents

     

       82
       82
       +
       	}

     

       83
       83
       +
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       84
       84
       +
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
       85
       +
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
       86
       +
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       87
       87
       +
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", ownerSlashRepo, url.PathEscape(ref), result.Parent)

     

       88
       88
       +
       		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       89
       89
       +
       		return

     

       90
       90
       +
       	}

     

       91
       91
       +
       	user := rp.oauth.GetUser(r)

     

       92
       92
       +
       	var breadcrumbs [][]string

     

       93
       93
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})

     

       94
       94
       +
       	if treePath != "" {

     

       95
       95
       +
       		for idx, elem := range strings.Split(treePath, "/") {

     

       96
       96
       +
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       97
       97
       +
       		}

     

       98
       98
       +
       	}

     

       99
       99
       +
       	sortFiles(result.Files)

     

       100
       100
       +
       

     

       101
       101
       +
       	rp.pages.RepoTree(w, pages.RepoTreeParams{

     

       102
       102
       +
       		LoggedInUser:     user,

     

       103
       103
       +
       		BreadCrumbs:      breadcrumbs,

     

       104
       104
       +
       		TreePath:         treePath,

     

       105
       105
       +
       		RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       106
       106
       +
       		RepoTreeResponse: result,

     

       107
       107
       +
       	})

     

       108
       108
       +
       }

+76 -162

appview/reporesolver/resolver.go

···

       1
       1
        
       package reporesolver

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"database/sql"

     

       6
       6
       -
       	"errors"

     

       7
       4
        
       	"fmt"

     

       8
       5
        
       	"log"

     

       9
       6
        
       	"net/http"

     
···

       12
       9
        
       	"strings"

     

       13
       10
        
       

     

       14
       11
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       15
       15
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       16
       12
        
       	"github.com/go-chi/chi/v5"

     

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

     

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

     

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

     

       20
       16
        
       	"tangled.org/core/appview/oauth"

     

       21
       21
       -
       	"tangled.org/core/appview/pages"

     

       22
       17
        
       	"tangled.org/core/appview/pages/repoinfo"

     

       23
       23
       -
       	"tangled.org/core/idresolver"

     

       24
       18
        
       	"tangled.org/core/rbac"

     

       25
       19
        
       )

     

       26
       20
        
       

     

       27
       27
       -
       type ResolvedRepo struct {

     

       28
       28
       -
       	models.Repo

     

       29
       29
       -
       	OwnerId    identity.Identity

     

       30
       30
       -
       	CurrentDir string

     

       31
       31
       -
       	Ref        string

     

       32
       32
       -
       

     

       33
       33
       -
       	rr *RepoResolver

     

       21
       21
       +
       type RepoResolver struct {

     

       22
       22
       +
       	config   *config.Config

     

       23
       23
       +
       	enforcer *rbac.Enforcer

     

       24
       24
       +
       	execer   db.Execer

     

       34
       25
        
       }

     

       35
       26
        
       

     

       36
       36
       -
       type RepoResolver struct {

     

       37
       37
       -
       	config     *config.Config

     

       38
       38
       -
       	enforcer   *rbac.Enforcer

     

       39
       39
       -
       	idResolver *idresolver.Resolver

     

       40
       40
       -
       	execer     db.Execer

     

       27
       27
       +
       func New(config *config.Config, enforcer *rbac.Enforcer, execer db.Execer) *RepoResolver {

     

       28
       28
       +
       	return &RepoResolver{config: config, enforcer: enforcer, execer: execer}

     

       41
       29
        
       }

     

       42
       30
        
       

     

       43
       43
       -
       func New(config *config.Config, enforcer *rbac.Enforcer, resolver *idresolver.Resolver, execer db.Execer) *RepoResolver {

     

       44
       44
       -
       	return &RepoResolver{config: config, enforcer: enforcer, idResolver: resolver, execer: execer}

     

       31
       31
       +
       // NOTE: this... should not even be here. the entire package will be removed in future refactor

     

       32
       32
       +
       func GetBaseRepoPath(r *http.Request, repo *models.Repo) string {

     

       33
       33
       +
       	var (

     

       34
       34
       +
       		user = chi.URLParam(r, "user")

     

       35
       35
       +
       		name = chi.URLParam(r, "repo")

     

       36
       36
       +
       	)

     

       37
       37
       +
       	if user == "" || name == "" {

     

       38
       38
       +
       		return repo.DidSlashRepo()

     

       39
       39
       +
       	}

     

       40
       40
       +
       	return path.Join(user, name)

     

       45
       41
        
       }

     

       46
       42
        
       

     

       47
       47
       -
       func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     

       43
       43
       +
       // TODO: move this out of `RepoResolver` struct

     

       44
       44
       +
       func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {

     

       48
       45
        
       	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       49
       46
        
       	if !ok {

     

       50
       47
        
       		log.Println("malformed middleware: `repo` not exist in context")

     

       51
       48
        
       		return nil, fmt.Errorf("malformed middleware")

     

       52
       49
        
       	}

     

       53
       53
       -
       	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       54
       54
       -
       	if !ok {

     

       55
       55
       -
       		log.Println("malformed middleware")

     

       56
       56
       -
       		return nil, fmt.Errorf("malformed middleware")

     

       57
       57
       -
       	}

     

       58
       50
        
       

     

       59
       59
       -
       	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))

     

       60
       60
       -
       	ref := chi.URLParam(r, "ref")

     

       61
       61
       -
       

     

       62
       62
       -
       	return &ResolvedRepo{

     

       63
       63
       -
       		Repo:       *repo,

     

       64
       64
       -
       		OwnerId:    id,

     

       65
       65
       -
       		CurrentDir: currentDir,

     

       66
       66
       -
       		Ref:        ref,

     

       67
       67
       -
       

     

       68
       68
       -
       		rr: rr,

     

       69
       69
       -
       	}, nil

     

       51
       51
       +
       	return repo, nil

     

       70
       52
        
       }

     

       71
       53
        
       

     

       72
       72
       -
       func (f *ResolvedRepo) OwnerDid() string {

     

       73
       73
       -
       	return f.OwnerId.DID.String()

     

       74
       74
       -
       }

     

       75
       75
       -
       

     

       76
       76
       -
       func (f *ResolvedRepo) OwnerHandle() string {

     

       77
       77
       -
       	return f.OwnerId.Handle.String()

     

       78
       78
       -
       }

     

       79
       79
       -
       

     

       80
       80
       -
       func (f *ResolvedRepo) OwnerSlashRepo() string {

     

       81
       81
       -
       	handle := f.OwnerId.Handle

     

       82
       82
       -
       

     

       83
       83
       -
       	var p string

     

       84
       84
       -
       	if handle != "" && !handle.IsInvalidHandle() {

     

       85
       85
       -
       		p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)

     

       86
       86
       -
       	} else {

     

       87
       87
       -
       		p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)

     

       54
       54
       +
       // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`

     

       55
       55
       +
       // 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`

     

       56
       56
       +
       // 3. [x] remove `ResolvedRepo`

     

       57
       57
       +
       // 4. [ ] replace reporesolver to reposervice

     

       58
       58
       +
       func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {

     

       59
       59
       +
       	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)

     

       60
       60
       +
       	repo, rok := r.Context().Value("repo").(*models.Repo)

     

       61
       61
       +
       	if !ook || !rok {

     

       62
       62
       +
       		log.Println("malformed request, failed to get repo from context")

     

       88
       63
        
       	}

     

       89
       64
        
       

     

       90
       90
       -
       	return p

     

       91
       91
       -
       }

     

       65
       65
       +
       	// get dir/ref

     

       66
       66
       +
       	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))

     

       67
       67
       +
       	ref := chi.URLParam(r, "ref")

     

       92
       68
        
       

     

       93
       93
       -
       func (f *ResolvedRepo) Collaborators(ctx context.Context) ([]pages.Collaborator, error) {

     

       94
       94
       -
       	repoCollaborators, err := f.rr.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)

     

       95
       95
       -
       	if err != nil {

     

       96
       96
       -
       		return nil, err

     

       69
       69
       +
       	repoAt := repo.RepoAt()

     

       70
       70
       +
       	isStarred := false

     

       71
       71
       +
       	roles := repoinfo.RolesInRepo{}

     

       72
       72
       +
       	if user != nil {

     

       73
       73
       +
       		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)

     

       74
       74
       +
       		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())

     

       97
       75
        
       	}

     

       98
       76
        
       

     

       99
       99
       -
       	var collaborators []pages.Collaborator

     

       100
       100
       -
       	for _, item := range repoCollaborators {

     

       101
       101
       -
       		// currently only two roles: owner and member

     

       102
       102
       -
       		var role string

     

       103
       103
       -
       		switch item[3] {

     

       104
       104
       -
       		case "repo:owner":

     

       105
       105
       -
       			role = "owner"

     

       106
       106
       -
       		case "repo:collaborator":

     

       107
       107
       -
       			role = "collaborator"

     

       108
       108
       -
       		default:

     

       109
       109
       -
       			continue

     

       77
       77
       +
       	stats := repo.RepoStats

     

       78
       78
       +
       	if stats == nil {

     

       79
       79
       +
       		starCount, err := db.GetStarCount(rr.execer, repoAt)

     

       80
       80
       +
       		if err != nil {

     

       81
       81
       +
       			log.Println("failed to get star count for ", repoAt)

     

       110
       82
        
       		}

     

       111
       111
       -
       

     

       112
       112
       -
       		did := item[0]

     

       113
       113
       -
       

     

       114
       114
       -
       		c := pages.Collaborator{

     

       115
       115
       -
       			Did:    did,

     

       116
       116
       -
       			Handle: "",

     

       117
       117
       -
       			Role:   role,

     

       83
       83
       +
       		issueCount, err := db.GetIssueCount(rr.execer, repoAt)

     

       84
       84
       +
       		if err != nil {

     

       85
       85
       +
       			log.Println("failed to get issue count for ", repoAt)

     

       118
       86
        
       		}

     

       119
       119
       -
       		collaborators = append(collaborators, c)

     

       120
       120
       -
       	}

     

       121
       121
       -
       

     

       122
       122
       -
       	// populate all collborators with handles

     

       123
       123
       -
       	identsToResolve := make([]string, len(collaborators))

     

       124
       124
       -
       	for i, collab := range collaborators {

     

       125
       125
       -
       		identsToResolve[i] = collab.Did

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	resolvedIdents := f.rr.idResolver.ResolveIdents(ctx, identsToResolve)

     

       129
       129
       -
       	for i, resolved := range resolvedIdents {

     

       130
       130
       -
       		if resolved != nil {

     

       131
       131
       -
       			collaborators[i].Handle = resolved.Handle.String()

     

       87
       87
       +
       		pullCount, err := db.GetPullCount(rr.execer, repoAt)

     

       88
       88
       +
       		if err != nil {

     

       89
       89
       +
       			log.Println("failed to get pull count for ", repoAt)

     

       132
       90
        
       		}

     

       133
       133
       -
       	}

     

       134
       134
       -
       

     

       135
       135
       -
       	return collaborators, nil

     

       136
       136
       -
       }

     

       137
       137
       -
       

     

       138
       138
       -
       // this function is a bit weird since it now returns RepoInfo from an entirely different

     

       139
       139
       -
       // package. we should refactor this or get rid of RepoInfo entirely.

     

       140
       140
       -
       func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {

     

       141
       141
       -
       	repoAt := f.RepoAt()

     

       142
       142
       -
       	isStarred := false

     

       143
       143
       -
       	if user != nil {

     

       144
       144
       -
       		isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)

     

       145
       145
       -
       	}

     

       146
       146
       -
       

     

       147
       147
       -
       	starCount, err := db.GetStarCount(f.rr.execer, repoAt)

     

       148
       148
       -
       	if err != nil {

     

       149
       149
       -
       		log.Println("failed to get star count for ", repoAt)

     

       150
       150
       -
       	}

     

       151
       151
       -
       	issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)

     

       152
       152
       -
       	if err != nil {

     

       153
       153
       -
       		log.Println("failed to get issue count for ", repoAt)

     

       154
       154
       -
       	}

     

       155
       155
       -
       	pullCount, err := db.GetPullCount(f.rr.execer, repoAt)

     

       156
       156
       -
       	if err != nil {

     

       157
       157
       -
       		log.Println("failed to get issue count for ", repoAt)

     

       158
       158
       -
       	}

     

       159
       159
       -
       	source, err := db.GetRepoSource(f.rr.execer, repoAt)

     

       160
       160
       -
       	if errors.Is(err, sql.ErrNoRows) {

     

       161
       161
       -
       		source = ""

     

       162
       162
       -
       	} else if err != nil {

     

       163
       163
       -
       		log.Println("failed to get repo source for ", repoAt, err)

     

       91
       91
       +
       		stats = &models.RepoStats{

     

       92
       92
       +
       			StarCount:  starCount,

     

       93
       93
       +
       			IssueCount: issueCount,

     

       94
       94
       +
       			PullCount:  pullCount,

     

       95
       95
       +
       		}

     

       164
       96
        
       	}

     

       165
       97
        
       

     

       166
       98
        
       	var sourceRepo *models.Repo

     

       167
       167
       -
       	if source != "" {

     

       168
       168
       -
       		sourceRepo, err = db.GetRepoByAtUri(f.rr.execer, source)

     

       99
       99
       +
       	var err error

     

       100
       100
       +
       	if repo.Source != "" {

     

       101
       101
       +
       		sourceRepo, err = db.GetRepoByAtUri(rr.execer, repo.Source)

     

       169
       102
        
       		if err != nil {

     

       170
       103
        
       			log.Println("failed to get repo by at uri", err)

     

       171
       104
        
       		}

     

       172
       105
        
       	}

     

       173
       106
        
       

     

       174
       174
       -
       	var sourceHandle *identity.Identity

     

       175
       175
       -
       	if sourceRepo != nil {

     

       176
       176
       -
       		sourceHandle, err = f.rr.idResolver.ResolveIdent(context.Background(), sourceRepo.Did)

     

       177
       177
       -
       		if err != nil {

     

       178
       178
       -
       			log.Println("failed to resolve source repo", err)

     

       179
       179
       -
       		}

     

       180
       180
       -
       	}

     

       107
       107
       +
       	repoInfo := repoinfo.RepoInfo{

     

       108
       108
       +
       		// this is basically a models.Repo

     

       109
       109
       +
       		OwnerDid:    ownerId.DID.String(),

     

       110
       110
       +
       		OwnerHandle: ownerId.Handle.String(),

     

       111
       111
       +
       		Name:        repo.Name,

     

       112
       112
       +
       		Rkey:        repo.Rkey,

     

       113
       113
       +
       		Description: repo.Description,

     

       114
       114
       +
       		Website:     repo.Website,

     

       115
       115
       +
       		Topics:      repo.Topics,

     

       116
       116
       +
       		Knot:        repo.Knot,

     

       117
       117
       +
       		Spindle:     repo.Spindle,

     

       118
       118
       +
       		Stats:       *stats,

     

       181
       119
        
       

     

       182
       182
       -
       	knot := f.Knot

     

       120
       120
       +
       		// fork repo upstream

     

       121
       121
       +
       		Source: sourceRepo,

     

       183
       122
        
       

     

       184
       184
       -
       	repoInfo := repoinfo.RepoInfo{

     

       185
       185
       -
       		OwnerDid:    f.OwnerDid(),

     

       186
       186
       -
       		OwnerHandle: f.OwnerHandle(),

     

       187
       187
       -
       		Name:        f.Name,

     

       188
       188
       -
       		Rkey:        f.Repo.Rkey,

     

       189
       189
       -
       		RepoAt:      repoAt,

     

       190
       190
       -
       		Description: f.Description,

     

       191
       191
       -
       		IsStarred:   isStarred,

     

       192
       192
       -
       		Knot:        knot,

     

       193
       193
       -
       		Spindle:     f.Spindle,

     

       194
       194
       -
       		Roles:       f.RolesInRepo(user),

     

       195
       195
       -
       		Stats: models.RepoStats{

     

       196
       196
       -
       			StarCount:  starCount,

     

       197
       197
       -
       			IssueCount: issueCount,

     

       198
       198
       -
       			PullCount:  pullCount,

     

       199
       199
       -
       		},

     

       200
       200
       -
       		CurrentDir: f.CurrentDir,

     

       201
       201
       -
       		Ref:        f.Ref,

     

       202
       202
       -
       	}

     

       123
       123
       +
       		// page context

     

       124
       124
       +
       		CurrentDir: currentDir,

     

       125
       125
       +
       		Ref:        ref,

     

       203
       126
        
       

     

       204
       204
       -
       	if sourceRepo != nil {

     

       205
       205
       -
       		repoInfo.Source = sourceRepo

     

       206
       206
       -
       		repoInfo.SourceHandle = sourceHandle.Handle.String()

     

       127
       127
       +
       		// info related to the session

     

       128
       128
       +
       		IsStarred: isStarred,

     

       129
       129
       +
       		Roles:     roles,

     

       207
       130
        
       	}

     

       208
       131
        
       

     

       209
       132
        
       	return repoInfo

     

       210
       210
       -
       }

     

       211
       211
       -
       

     

       212
       212
       -
       func (f *ResolvedRepo) RolesInRepo(u *oauth.User) repoinfo.RolesInRepo {

     

       213
       213
       -
       	if u != nil {

     

       214
       214
       -
       		r := f.rr.enforcer.GetPermissionsInRepo(u.Did, f.Knot, f.DidSlashRepo())

     

       215
       215
       -
       		return repoinfo.RolesInRepo{Roles: r}

     

       216
       216
       -
       	} else {

     

       217
       217
       -
       		return repoinfo.RolesInRepo{}

     

       218
       218
       -
       	}

     

       219
       133
        
       }

     

       220
       134
        
       

     

       221
       135
        
       // extractPathAfterRef gets the actual repository path

+5 -4

appview/serververify/verify.go

···

       9
       9
        
       	"tangled.org/core/api/tangled"

     

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

     

       11
       11
        
       	"tangled.org/core/appview/xrpcclient"

     

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

     

       12
       13
        
       	"tangled.org/core/rbac"

     

       13
       14
        
       )

     

       14
       15
        
       

     
···

       76
       77
        
       	// mark this spindle as verified in the db

     

       77
       78
        
       	rowId, err := db.VerifySpindle(

     

       78
       79
        
       		tx,

     

       79
       79
       -
       		db.FilterEq("owner", owner),

     

       80
       80
       -
       		db.FilterEq("instance", instance),

     

       80
       80
       +
       		orm.FilterEq("owner", owner),

     

       81
       81
       +
       		orm.FilterEq("instance", instance),

     

       81
       82
        
       	)

     

       82
       83
        
       	if err != nil {

     

       83
       84
        
       		return 0, fmt.Errorf("failed to write to DB: %w", err)

     
···

       115
       116
        
       	// mark as registered

     

       116
       117
        
       	err = db.MarkRegistered(

     

       117
       118
        
       		tx,

     

       118
       118
       -
       		db.FilterEq("did", owner),

     

       119
       119
       -
       		db.FilterEq("domain", domain),

     

       119
       119
       +
       		orm.FilterEq("did", owner),

     

       120
       120
       +
       		orm.FilterEq("domain", domain),

     

       120
       121
        
       	)

     

       121
       122
        
       	if err != nil {

     

       122
       123
        
       		return fmt.Errorf("failed to register domain: %w", err)

appview/settings/settings.go

···

       43
       43
        
       		{"Name": "keys", "Icon": "key"},

     

       44
       44
        
       		{"Name": "emails", "Icon": "mail"},

     

       45
       45
        
       		{"Name": "notifications", "Icon": "bell"},

     

       46
       46
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       47
       47
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       46
       48
        
       	}

     

       47
       49
        
       )

     

       48
       50
        
       

     
···

       120
       122
        
       		PullCommented:      r.FormValue("pull_commented") == "on",

     

       121
       123
        
       		PullMerged:         r.FormValue("pull_merged") == "on",

     

       122
       124
        
       		Followed:           r.FormValue("followed") == "on",

     

       125
       125
       +
       		UserMentioned:      r.FormValue("user_mentioned") == "on",

     

       123
       126
        
       		EmailNotifications: r.FormValue("email_notifications") == "on",

     

       124
       127
        
       	}

     

       125
       128

+53 -26

appview/spindles/spindles.go

···

       6
       6
        
       	"log/slog"

     

       7
       7
        
       	"net/http"

     

       8
       8
        
       	"slices"

     

       9
       9
       +
       	"strings"

     

       9
       10
        
       	"time"

     

       10
       11
        
       

     

       11
       12
        
       	"github.com/go-chi/chi/v5"

     
···

       19
       20
        
       	"tangled.org/core/appview/serververify"

     

       20
       21
        
       	"tangled.org/core/appview/xrpcclient"

     

       21
       22
        
       	"tangled.org/core/idresolver"

     

       23
       23
       +
       	"tangled.org/core/orm"

     

       22
       24
        
       	"tangled.org/core/rbac"

     

       23
       25
        
       	"tangled.org/core/tid"

     

       24
       26
        
       

     
···

       37
       39
        
       	Logger     *slog.Logger

     

       38
       40
        
       }

     

       39
       41
        
       

     

       42
       42
       +
       type tab = map[string]any

     

       43
       43
       +
       

     

       44
       44
       +
       var (

     

       45
       45
       +
       	spindlesTabs []tab = []tab{

     

       46
       46
       +
       		{"Name": "profile", "Icon": "user"},

     

       47
       47
       +
       		{"Name": "keys", "Icon": "key"},

     

       48
       48
       +
       		{"Name": "emails", "Icon": "mail"},

     

       49
       49
       +
       		{"Name": "notifications", "Icon": "bell"},

     

       50
       50
       +
       		{"Name": "knots", "Icon": "volleyball"},

     

       51
       51
       +
       		{"Name": "spindles", "Icon": "spool"},

     

       52
       52
       +
       	}

     

       53
       53
       +
       )

     

       54
       54
       +
       

     

       40
       55
        
       func (s *Spindles) Router() http.Handler {

     

       41
       56
        
       	r := chi.NewRouter()

     

       42
       57
        
       

     
···

       57
       72
        
       	user := s.OAuth.GetUser(r)

     

       58
       73
        
       	all, err := db.GetSpindles(

     

       59
       74
        
       		s.Db,

     

       60
       60
       -
       		db.FilterEq("owner", user.Did),

     

       75
       75
       +
       		orm.FilterEq("owner", user.Did),

     

       61
       76
        
       	)

     

       62
       77
        
       	if err != nil {

     

       63
       78
        
       		s.Logger.Error("failed to fetch spindles", "err", err)

     
···

       68
       83
        
       	s.Pages.Spindles(w, pages.SpindlesParams{

     

       69
       84
        
       		LoggedInUser: user,

     

       70
       85
        
       		Spindles:     all,

     

       86
       86
       +
       		Tabs:         spindlesTabs,

     

       87
       87
       +
       		Tab:          "spindles",

     

       71
       88
        
       	})

     

       72
       89
        
       }

     

       73
       90
        
       

     
···

       85
       102
        
       

     

       86
       103
        
       	spindles, err := db.GetSpindles(

     

       87
       104
        
       		s.Db,

     

       88
       88
       -
       		db.FilterEq("instance", instance),

     

       89
       89
       -
       		db.FilterEq("owner", user.Did),

     

       90
       90
       -
       		db.FilterIsNot("verified", "null"),

     

       105
       105
       +
       		orm.FilterEq("instance", instance),

     

       106
       106
       +
       		orm.FilterEq("owner", user.Did),

     

       107
       107
       +
       		orm.FilterIsNot("verified", "null"),

     

       91
       108
        
       	)

     

       92
       109
        
       	if err != nil || len(spindles) != 1 {

     

       93
       110
        
       		l.Error("failed to get spindle", "err", err, "len(spindles)", len(spindles))

     
···

       107
       124
        
       	repos, err := db.GetRepos(

     

       108
       125
        
       		s.Db,

     

       109
       126
        
       		0,

     

       110
       110
       -
       		db.FilterEq("spindle", instance),

     

       127
       127
       +
       		orm.FilterEq("spindle", instance),

     

       111
       128
        
       	)

     

       112
       129
        
       	if err != nil {

     

       113
       130
        
       		l.Error("failed to get spindle repos", "err", err)

     
···

       126
       143
        
       		Spindle:      spindle,

     

       127
       144
        
       		Members:      members,

     

       128
       145
        
       		Repos:        repoMap,

     

       146
       146
       +
       		Tabs:         spindlesTabs,

     

       147
       147
       +
       		Tab:          "spindles",

     

       129
       148
        
       	})

     

       130
       149
        
       }

     

       131
       150
        
       

     
···

       146
       165
        
       	}

     

       147
       166
        
       

     

       148
       167
        
       	instance := r.FormValue("instance")

     

       168
       168
       +
       	// Strip protocol, trailing slashes, and whitespace

     

       169
       169
       +
       	// Rkey cannot contain slashes

     

       170
       170
       +
       	instance = strings.TrimSpace(instance)

     

       171
       171
       +
       	instance = strings.TrimPrefix(instance, "https://")

     

       172
       172
       +
       	instance = strings.TrimPrefix(instance, "http://")

     

       173
       173
       +
       	instance = strings.TrimSuffix(instance, "/")

     

       149
       174
        
       	if instance == "" {

     

       150
       175
        
       		s.Pages.Notice(w, noticeId, "Incomplete form.")

     

       151
       176
        
       		return

     
···

       266
       291
        
       

     

       267
       292
        
       	spindles, err := db.GetSpindles(

     

       268
       293
        
       		s.Db,

     

       269
       269
       -
       		db.FilterEq("owner", user.Did),

     

       270
       270
       -
       		db.FilterEq("instance", instance),

     

       294
       294
       +
       		orm.FilterEq("owner", user.Did),

     

       295
       295
       +
       		orm.FilterEq("instance", instance),

     

       271
       296
        
       	)

     

       272
       297
        
       	if err != nil || len(spindles) != 1 {

     

       273
       298
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       295
       320
        
       	// remove spindle members first

     

       296
       321
        
       	err = db.RemoveSpindleMember(

     

       297
       322
        
       		tx,

     

       298
       298
       -
       		db.FilterEq("did", user.Did),

     

       299
       299
       -
       		db.FilterEq("instance", instance),

     

       323
       323
       +
       		orm.FilterEq("did", user.Did),

     

       324
       324
       +
       		orm.FilterEq("instance", instance),

     

       300
       325
        
       	)

     

       301
       326
        
       	if err != nil {

     

       302
       327
        
       		l.Error("failed to remove spindle members", "err", err)

     
···

       306
       331
        
       

     

       307
       332
        
       	err = db.DeleteSpindle(

     

       308
       333
        
       		tx,

     

       309
       309
       -
       		db.FilterEq("owner", user.Did),

     

       310
       310
       -
       		db.FilterEq("instance", instance),

     

       334
       334
       +
       		orm.FilterEq("owner", user.Did),

     

       335
       335
       +
       		orm.FilterEq("instance", instance),

     

       311
       336
        
       	)

     

       312
       337
        
       	if err != nil {

     

       313
       338
        
       		l.Error("failed to delete spindle", "err", err)

     
···

       358
       383
        
       

     

       359
       384
        
       	shouldRedirect := r.Header.Get("shouldRedirect")

     

       360
       385
        
       	if shouldRedirect == "true" {

     

       361
       361
       -
       		s.Pages.HxRedirect(w, "/spindles")

     

       386
       386
       +
       		s.Pages.HxRedirect(w, "/settings/spindles")

     

       362
       387
        
       		return

     

       363
       388
        
       	}

     

       364
       389
        
       

     
···

       386
       411
        
       

     

       387
       412
        
       	spindles, err := db.GetSpindles(

     

       388
       413
        
       		s.Db,

     

       389
       389
       -
       		db.FilterEq("owner", user.Did),

     

       390
       390
       -
       		db.FilterEq("instance", instance),

     

       414
       414
       +
       		orm.FilterEq("owner", user.Did),

     

       415
       415
       +
       		orm.FilterEq("instance", instance),

     

       391
       416
        
       	)

     

       392
       417
        
       	if err != nil || len(spindles) != 1 {

     

       393
       418
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       429
       454
        
       

     

       430
       455
        
       	verifiedSpindle, err := db.GetSpindles(

     

       431
       456
        
       		s.Db,

     

       432
       432
       -
       		db.FilterEq("id", rowId),

     

       457
       457
       +
       		orm.FilterEq("id", rowId),

     

       433
       458
        
       	)

     

       434
       459
        
       	if err != nil || len(verifiedSpindle) != 1 {

     

       435
       460
        
       		l.Error("failed get new spindle", "err", err)

     
···

       462
       487
        
       

     

       463
       488
        
       	spindles, err := db.GetSpindles(

     

       464
       489
        
       		s.Db,

     

       465
       465
       -
       		db.FilterEq("owner", user.Did),

     

       466
       466
       -
       		db.FilterEq("instance", instance),

     

       490
       490
       +
       		orm.FilterEq("owner", user.Did),

     

       491
       491
       +
       		orm.FilterEq("instance", instance),

     

       467
       492
        
       	)

     

       468
       493
        
       	if err != nil || len(spindles) != 1 {

     

       469
       494
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       484
       509
        
       	}

     

       485
       510
        
       

     

       486
       511
        
       	member := r.FormValue("member")

     

       512
       512
       +
       	member = strings.TrimPrefix(member, "@")

     

       487
       513
        
       	if member == "" {

     

       488
       514
        
       		l.Error("empty member")

     

       489
       515
        
       		s.Pages.Notice(w, noticeId, "Failed to add member, empty form.")

     
···

       573
       599
        
       	}

     

       574
       600
        
       

     

       575
       601
        
       	// success

     

       576
       576
       -
       	s.Pages.HxRedirect(w, fmt.Sprintf("/spindles/%s", instance))

     

       602
       602
       +
       	s.Pages.HxRedirect(w, fmt.Sprintf("/settings/spindles/%s", instance))

     

       577
       603
        
       }

     

       578
       604
        
       

     

       579
       605
        
       func (s *Spindles) removeMember(w http.ResponseWriter, r *http.Request) {

     
···

       597
       623
        
       

     

       598
       624
        
       	spindles, err := db.GetSpindles(

     

       599
       625
        
       		s.Db,

     

       600
       600
       -
       		db.FilterEq("owner", user.Did),

     

       601
       601
       -
       		db.FilterEq("instance", instance),

     

       626
       626
       +
       		orm.FilterEq("owner", user.Did),

     

       627
       627
       +
       		orm.FilterEq("instance", instance),

     

       602
       628
        
       	)

     

       603
       629
        
       	if err != nil || len(spindles) != 1 {

     

       604
       630
        
       		l.Error("failed to retrieve instance", "err", err, "len(spindles)", len(spindles))

     
···

       613
       639
        
       	}

     

       614
       640
        
       

     

       615
       641
        
       	member := r.FormValue("member")

     

       642
       642
       +
       	member = strings.TrimPrefix(member, "@")

     

       616
       643
        
       	if member == "" {

     

       617
       644
        
       		l.Error("empty member")

     

       618
       645
        
       		s.Pages.Notice(w, noticeId, "Failed to remove member, empty form.")

     
···

       646
       673
        
       	// get the record from the DB first:

     

       647
       674
        
       	members, err := db.GetSpindleMembers(

     

       648
       675
        
       		s.Db,

     

       649
       649
       -
       		db.FilterEq("did", user.Did),

     

       650
       650
       -
       		db.FilterEq("instance", instance),

     

       651
       651
       -
       		db.FilterEq("subject", memberId.DID),

     

       676
       676
       +
       		orm.FilterEq("did", user.Did),

     

       677
       677
       +
       		orm.FilterEq("instance", instance),

     

       678
       678
       +
       		orm.FilterEq("subject", memberId.DID),

     

       652
       679
        
       	)

     

       653
       680
        
       	if err != nil || len(members) != 1 {

     

       654
       681
        
       		l.Error("failed to get member", "err", err)

     
···

       659
       686
        
       	// remove from db

     

       660
       687
        
       	if err = db.RemoveSpindleMember(

     

       661
       688
        
       		tx,

     

       662
       662
       -
       		db.FilterEq("did", user.Did),

     

       663
       663
       -
       		db.FilterEq("instance", instance),

     

       664
       664
       -
       		db.FilterEq("subject", memberId.DID),

     

       689
       689
       +
       		orm.FilterEq("did", user.Did),

     

       690
       690
       +
       		orm.FilterEq("instance", instance),

     

       691
       691
       +
       		orm.FilterEq("subject", memberId.DID),

     

       665
       692
        
       	); err != nil {

     

       666
       693
        
       		l.Error("failed to remove spindle member", "err", err)

     

       667
       694
        
       		fail()

appview/state/follow.go

···

       26
       26
        
       	subjectIdent, err := s.idResolver.ResolveIdent(r.Context(), subject)

     

       27
       27
        
       	if err != nil {

     

       28
       28
        
       		log.Println("failed to follow, invalid did")

     

       29
       29
       +
       		return

     

       29
       30
        
       	}

     

       30
       31
        
       

     

       31
       32
        
       	if currentUser.Did == subjectIdent.DID.String() {

+16 -12

appview/state/gfi.go

···

       1
       1
        
       package state

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"fmt"

     

       5
       4
        
       	"log"

     

       6
       5
        
       	"net/http"

     

       7
       6
        
       	"sort"

     

       8
       7
        
       

     

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

     

       10
       10
       -
       	"tangled.org/core/api/tangled"

     

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

     

       12
       10
        
       	"tangled.org/core/appview/models"

     

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

     

       14
       12
        
       	"tangled.org/core/appview/pagination"

     

       15
       13
        
       	"tangled.org/core/consts"

     

       14
       14
       +
       	"tangled.org/core/orm"

     

       16
       15
        
       )

     

       17
       16
        
       

     

       18
       17
        
       func (s *State) GoodFirstIssues(w http.ResponseWriter, r *http.Request) {

     

       19
       18
        
       	user := s.oauth.GetUser(r)

     

       20
       19
        
       

     

       21
       21
       -
       	page, ok := r.Context().Value("page").(pagination.Page)

     

       22
       22
       -
       	if !ok {

     

       23
       23
       -
       		page = pagination.FirstPage()

     

       24
       24
       -
       	}

     

       20
       20
       +
       	page := pagination.FromContext(r.Context())

     

       25
       21
        
       

     

       26
       26
       -
       	goodFirstIssueLabel := fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, "good-first-issue")

     

       22
       22
       +
       	goodFirstIssueLabel := s.config.Label.GoodFirstIssue

     

       27
       23
        
       

     

       28
       28
       -
       	repoLabels, err := db.GetRepoLabels(s.db, db.FilterEq("label_at", goodFirstIssueLabel))

     

       24
       24
       +
       	gfiLabelDef, err := db.GetLabelDefinition(s.db, orm.FilterEq("at_uri", goodFirstIssueLabel))

     

       25
       25
       +
       	if err != nil {

     

       26
       26
       +
       		log.Println("failed to get gfi label def", err)

     

       27
       27
       +
       		s.pages.Error500(w)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	repoLabels, err := db.GetRepoLabels(s.db, orm.FilterEq("label_at", goodFirstIssueLabel))

     

       29
       32
        
       	if err != nil {

     

       30
       33
        
       		log.Println("failed to get repo labels", err)

     

       31
       34
        
       		s.pages.Error503(w)

     
···

       38
       41
        
       			RepoGroups:   []*models.RepoGroup{},

     

       39
       42
        
       			LabelDefs:    make(map[string]*models.LabelDefinition),

     

       40
       43
        
       			Page:         page,

     

       44
       44
       +
       			GfiLabel:     gfiLabelDef,

     

       41
       45
        
       		})

     

       42
       46
        
       		return

     

       43
       47
        
       	}

     
···

       52
       56
        
       		pagination.Page{

     

       53
       57
        
       			Limit: 500,

     

       54
       58
        
       		},

     

       55
       55
       -
       		db.FilterIn("repo_at", repoUris),

     

       56
       56
       -
       		db.FilterEq("open", 1),

     

       59
       59
       +
       		orm.FilterIn("repo_at", repoUris),

     

       60
       60
       +
       		orm.FilterEq("open", 1),

     

       57
       61
        
       	)

     

       58
       62
        
       	if err != nil {

     

       59
       63
        
       		log.Println("failed to get issues", err)

     
···

       129
       133
        
       		}

     

       130
       134
        
       

     

       131
       135
        
       		if len(uriList) > 0 {

     

       132
       132
       -
       			allLabelDefs, err = db.GetLabelDefinitions(s.db, db.FilterIn("at_uri", uriList))

     

       136
       136
       +
       			allLabelDefs, err = db.GetLabelDefinitions(s.db, orm.FilterIn("at_uri", uriList))

     

       133
       137
        
       			if err != nil {

     

       134
       138
        
       				log.Println("failed to fetch labels", err)

     

       135
       139
        
       			}

     
···

       146
       150
        
       		RepoGroups:   paginatedGroups,

     

       147
       151
        
       		LabelDefs:    labelDefsMap,

     

       148
       152
        
       		Page:         page,

     

       149
       149
       -
       		GfiLabel:     labelDefsMap[goodFirstIssueLabel],

     

       153
       153
       +
       		GfiLabel:     gfiLabelDef,

     

       150
       154
        
       	})

     

       151
       155
        
       }

+6 -5

appview/state/knotstream.go

···

       16
       16
        
       	ec "tangled.org/core/eventconsumer"

     

       17
       17
        
       	"tangled.org/core/eventconsumer/cursor"

     

       18
       18
        
       	"tangled.org/core/log"

     

       19
       19
       +
       	"tangled.org/core/orm"

     

       19
       20
        
       	"tangled.org/core/rbac"

     

       20
       21
        
       	"tangled.org/core/workflow"

     

       21
       22
        
       

     
···

       30
       31
        
       

     

       31
       32
        
       	knots, err := db.GetRegistrations(

     

       32
       33
        
       		d,

     

       33
       33
       -
       		db.FilterIsNot("registered", "null"),

     

       34
       34
       +
       		orm.FilterIsNot("registered", "null"),

     

       34
       35
        
       	)

     

       35
       36
        
       	if err != nil {

     

       36
       37
        
       		return nil, err

     
···

       143
       144
        
       	repos, err := db.GetRepos(

     

       144
       145
        
       		d,

     

       145
       146
        
       		0,

     

       146
       146
       -
       		db.FilterEq("did", record.RepoDid),

     

       147
       147
       -
       		db.FilterEq("name", record.RepoName),

     

       147
       147
       +
       		orm.FilterEq("did", record.RepoDid),

     

       148
       148
       +
       		orm.FilterEq("name", record.RepoName),

     

       148
       149
        
       	)

     

       149
       150
        
       	if err != nil {

     

       150
       151
        
       		return fmt.Errorf("failed to look for repo in DB (%s/%s): %w", record.RepoDid, record.RepoName, err)

     
···

       209
       210
        
       	repos, err := db.GetRepos(

     

       210
       211
        
       		d,

     

       211
       212
        
       		0,

     

       212
       212
       -
       		db.FilterEq("did", record.TriggerMetadata.Repo.Did),

     

       213
       213
       -
       		db.FilterEq("name", record.TriggerMetadata.Repo.Repo),

     

       213
       213
       +
       		orm.FilterEq("did", record.TriggerMetadata.Repo.Did),

     

       214
       214
       +
       		orm.FilterEq("name", record.TriggerMetadata.Repo.Repo),

     

       214
       215
        
       	)

     

       215
       216
        
       	if err != nil {

     

       216
       217
        
       		return fmt.Errorf("failed to look for repo in DB: nsid %s, rkey %s, %w", msg.Nsid, msg.Rkey, err)

appview/state/login.go

···

       14
       14
        
       	switch r.Method {

     

       15
       15
        
       	case http.MethodGet:

     

       16
       16
        
       		returnURL := r.URL.Query().Get("return_url")

     

       17
       17
       +
       		errorCode := r.URL.Query().Get("error")

     

       17
       18
        
       		s.pages.Login(w, pages.LoginParams{

     

       18
       19
        
       			ReturnUrl: returnURL,

     

       20
       20
       +
       			ErrorCode: errorCode,

     

       19
       21
        
       		})

     

       20
       22
        
       	case http.MethodPost:

     

       21
       23
        
       		handle := r.FormValue("handle")

     
···

       44
       46
        
       

     

       45
       47
        
       		redirectURL, err := s.oauth.ClientApp.StartAuthFlow(r.Context(), handle)

     

       46
       48
        
       		if err != nil {

     

       49
       49
       +
       			l.Error("failed to start auth", "err", err)

     

       47
       50
        
       			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       48
       51
        
       			return

     

       49
       52
        
       		}

+30 -21

appview/state/profile.go

···

       19
       19
        
       	"tangled.org/core/appview/db"

     

       20
       20
        
       	"tangled.org/core/appview/models"

     

       21
       21
        
       	"tangled.org/core/appview/pages"

     

       22
       22
       +
       	"tangled.org/core/orm"

     

       22
       23
        
       )

     

       23
       24
        
       

     

       24
       25
        
       func (s *State) Profile(w http.ResponseWriter, r *http.Request) {

     
···

       56
       57
        
       		return nil, fmt.Errorf("failed to get profile: %w", err)

     

       57
       58
        
       	}

     

       58
       59
        
       

     

       59
       59
       -
       	repoCount, err := db.CountRepos(s.db, db.FilterEq("did", did))

     

       60
       60
       +
       	repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did))

     

       60
       61
        
       	if err != nil {

     

       61
       62
        
       		return nil, fmt.Errorf("failed to get repo count: %w", err)

     

       62
       63
        
       	}

     

       63
       64
        
       

     

       64
       64
       -
       	stringCount, err := db.CountStrings(s.db, db.FilterEq("did", did))

     

       65
       65
       +
       	stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did))

     

       65
       66
        
       	if err != nil {

     

       66
       67
        
       		return nil, fmt.Errorf("failed to get string count: %w", err)

     

       67
       68
        
       	}

     

       68
       69
        
       

     

       69
       69
       -
       	starredCount, err := db.CountStars(s.db, db.FilterEq("starred_by_did", did))

     

       70
       70
       +
       	starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did))

     

       70
       71
        
       	if err != nil {

     

       71
       72
        
       		return nil, fmt.Errorf("failed to get starred repo count: %w", err)

     

       72
       73
        
       	}

     
···

       86
       87
        
       	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       87
       88
        
       	punchcard, err := db.MakePunchcard(

     

       88
       89
        
       		s.db,

     

       89
       89
       -
       		db.FilterEq("did", did),

     

       90
       90
       -
       		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       91
       91
       -
       		db.FilterLte("date", now.Format(time.DateOnly)),

     

       90
       90
       +
       		orm.FilterEq("did", did),

     

       91
       91
       +
       		orm.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       92
       92
       +
       		orm.FilterLte("date", now.Format(time.DateOnly)),

     

       92
       93
        
       	)

     

       93
       94
        
       	if err != nil {

     

       94
       95
        
       		return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)

     
···

       96
       97
        
       

     

       97
       98
        
       	return &pages.ProfileCard{

     

       98
       99
        
       		UserDid:      did,

     

       99
       99
       -
       		UserHandle:   ident.Handle.String(),

     

       100
       100
        
       		Profile:      profile,

     

       101
       101
        
       		FollowStatus: followStatus,

     

       102
       102
        
       		Stats: pages.ProfileStats{

     
···

       119
       119
        
       		s.pages.Error500(w)

     

       120
       120
        
       		return

     

       121
       121
        
       	}

     

       122
       122
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       122
       122
       +
       	l = l.With("profileDid", profile.UserDid)

     

       123
       123
        
       

     

       124
       124
        
       	repos, err := db.GetRepos(

     

       125
       125
        
       		s.db,

     

       126
       126
        
       		0,

     

       127
       127
       -
       		db.FilterEq("did", profile.UserDid),

     

       127
       127
       +
       		orm.FilterEq("did", profile.UserDid),

     

       128
       128
        
       	)

     

       129
       129
        
       	if err != nil {

     

       130
       130
        
       		l.Error("failed to fetch repos", "err", err)

     
···

       162
       162
        
       		l.Error("failed to create timeline", "err", err)

     

       163
       163
        
       	}

     

       164
       164
        
       

     

       165
       165
       +
       	// populate commit counts in the timeline, using the punchcard

     

       166
       166
       +
       	currentMonth := time.Now().Month()

     

       167
       167
       +
       	for _, p := range profile.Punchcard.Punches {

     

       168
       168
       +
       		idx := currentMonth - p.Date.Month()

     

       169
       169
       +
       		if int(idx) < len(timeline.ByMonth) {

     

       170
       170
       +
       			timeline.ByMonth[idx].Commits += p.Count

     

       171
       171
       +
       		}

     

       172
       172
       +
       	}

     

       173
       173
       +
       

     

       165
       174
        
       	s.pages.ProfileOverview(w, pages.ProfileOverviewParams{

     

       166
       175
        
       		LoggedInUser:       s.oauth.GetUser(r),

     

       167
       176
        
       		Card:               profile,

     
···

       180
       189
        
       		s.pages.Error500(w)

     

       181
       190
        
       		return

     

       182
       191
        
       	}

     

       183
       183
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       192
       192
       +
       	l = l.With("profileDid", profile.UserDid)

     

       184
       193
        
       

     

       185
       194
        
       	repos, err := db.GetRepos(

     

       186
       195
        
       		s.db,

     

       187
       196
        
       		0,

     

       188
       188
       -
       		db.FilterEq("did", profile.UserDid),

     

       197
       197
       +
       		orm.FilterEq("did", profile.UserDid),

     

       189
       198
        
       	)

     

       190
       199
        
       	if err != nil {

     

       191
       200
        
       		l.Error("failed to get repos", "err", err)

     
···

       209
       218
        
       		s.pages.Error500(w)

     

       210
       219
        
       		return

     

       211
       220
        
       	}

     

       212
       212
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       221
       221
       +
       	l = l.With("profileDid", profile.UserDid)

     

       213
       222
        
       

     

       214
       214
       -
       	stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))

     

       223
       223
       +
       	stars, err := db.GetRepoStars(s.db, 0, orm.FilterEq("did", profile.UserDid))

     

       215
       224
        
       	if err != nil {

     

       216
       225
        
       		l.Error("failed to get stars", "err", err)

     

       217
       226
        
       		s.pages.Error500(w)

     
···

       219
       228
        
       	}

     

       220
       229
        
       	var repos []models.Repo

     

       221
       230
        
       	for _, s := range stars {

     

       222
       222
       -
       		if s.Repo != nil {

     

       223
       223
       -
       			repos = append(repos, *s.Repo)

     

       224
       224
       -
       		}

     

       231
       231
       +
       		repos = append(repos, *s.Repo)

     

       225
       232
        
       	}

     

       226
       233
        
       

     

       227
       234
        
       	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{

     
···

       240
       247
        
       		s.pages.Error500(w)

     

       241
       248
        
       		return

     

       242
       249
        
       	}

     

       243
       243
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       250
       250
       +
       	l = l.With("profileDid", profile.UserDid)

     

       244
       251
        
       

     

       245
       245
       -
       	strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))

     

       252
       252
       +
       	strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid))

     

       246
       253
        
       	if err != nil {

     

       247
       254
        
       		l.Error("failed to get strings", "err", err)

     

       248
       255
        
       		s.pages.Error500(w)

     
···

       272
       279
        
       	if err != nil {

     

       273
       280
        
       		return nil, err

     

       274
       281
        
       	}

     

       275
       275
       -
       	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)

     

       282
       282
       +
       	l = l.With("profileDid", profile.UserDid)

     

       276
       283
        
       

     

       277
       284
        
       	loggedInUser := s.oauth.GetUser(r)

     

       278
       285
        
       	params := FollowsPageParams{

     
···

       294
       301
        
       		followDids = append(followDids, extractDid(follow))

     

       295
       302
        
       	}

     

       296
       303
        
       

     

       297
       297
       -
       	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       304
       304
       +
       	profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids))

     

       298
       305
        
       	if err != nil {

     

       299
       306
        
       		l.Error("failed to get profiles", "followDids", followDids, "err", err)

     

       300
       307
        
       		return &params, err

     
···

       538
       545
        
       	profile.Description = r.FormValue("description")

     

       539
       546
        
       	profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"

     

       540
       547
        
       	profile.Location = r.FormValue("location")

     

       548
       548
       +
       	profile.Pronouns = r.FormValue("pronouns")

     

       541
       549
        
       

     

       542
       550
        
       	var links [5]string

     

       543
       551
        
       	for i := range 5 {

     
···

       652
       660
        
       				Location:           &profile.Location,

     

       653
       661
        
       				PinnedRepositories: pinnedRepoStrings,

     

       654
       662
        
       				Stats:              vanityStats[:],

     

       663
       663
       +
       				Pronouns:           &profile.Pronouns,

     

       655
       664
        
       			}},

     

       656
       665
        
       		SwapRecord: cid,

     

       657
       666
        
       	})

     
···

       695
       704
        
       		log.Printf("getting profile data for %s: %s", user.Did, err)

     

       696
       705
        
       	}

     

       697
       706
        
       

     

       698
       698
       -
       	repos, err := db.GetRepos(s.db, 0, db.FilterEq("did", user.Did))

     

       707
       707
       +
       	repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Did))

     

       699
       708
        
       	if err != nil {

     

       700
       709
        
       		log.Printf("getting repos for %s: %s", user.Did, err)

     

       701
       710
        
       	}

+51 -39

appview/state/router.go

···

       42
       42
        
       

     

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

     

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

     

       45
       45
       -
       		if strings.HasPrefix(pat, "did:") || strings.HasPrefix(pat, "@") {

     

       46
       46
       -
       			userRouter.ServeHTTP(w, r)

     

       47
       47
       -
       		} else {

     

       48
       48
       -
       			// Check if the first path element is a valid handle without '@' or a flattened DID

     

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

     

       50
       50
       -
       			if len(pathParts) > 0 {

     

       51
       51
       -
       				if userutil.IsHandleNoAt(pathParts[0]) {

     

       52
       52
       -
       					// Redirect to the same path but with '@' prefixed to the handle

     

       53
       53
       -
       					redirectPath := "@" + pat

     

       54
       54
       -
       					http.Redirect(w, r, "/"+redirectPath, http.StatusFound)

     

       55
       55
       -
       					return

     

       56
       56
       -
       				} else if userutil.IsFlattenedDid(pathParts[0]) {

     

       57
       57
       -
       					// Redirect to the unflattened DID version

     

       58
       58
       -
       					unflattenedDid := userutil.UnflattenDid(pathParts[0])

     

       59
       59
       -
       					var redirectPath string

     

       60
       60
       -
       					if len(pathParts) > 1 {

     

       61
       61
       -
       						redirectPath = unflattenedDid + "/" + pathParts[1]

     

       62
       62
       -
       					} else {

     

       63
       63
       -
       						redirectPath = unflattenedDid

     

       64
       64
       -
       					}

     

       65
       65
       -
       					http.Redirect(w, r, "/"+redirectPath, http.StatusFound)

     

       66
       66
       -
       					return

     

       67
       67
       -
       				}

     

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

     

       46
       46
       +
       

     

       47
       47
       +
       		if len(pathParts) > 0 {

     

       48
       48
       +
       			firstPart := pathParts[0]

     

       49
       49
       +
       

     

       50
       50
       +
       			// if using a DID or handle, just continue as per usual

     

       51
       51
       +
       			if userutil.IsDid(firstPart) || userutil.IsHandle(firstPart) {

     

       52
       52
       +
       				userRouter.ServeHTTP(w, r)

     

       53
       53
       +
       				return

     

       54
       54
       +
       			}

     

       55
       55
       +
       

     

       56
       56
       +
       			// if using a flattened DID (like you would in go modules), unflatten

     

       57
       57
       +
       			if userutil.IsFlattenedDid(firstPart) {

     

       58
       58
       +
       				unflattenedDid := userutil.UnflattenDid(firstPart)

     

       59
       59
       +
       				redirectPath := strings.Join(append([]string{unflattenedDid}, pathParts[1:]...), "/")

     

       60
       60
       +
       

     

       61
       61
       +
       				redirectURL := *r.URL

     

       62
       62
       +
       				redirectURL.Path = "/" + redirectPath

     

       63
       63
       +
       

     

       64
       64
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       65
       65
       +
       				return

     

       68
       66
        
       			}

     

       69
       69
       -
       			standardRouter.ServeHTTP(w, r)

     

       67
       67
       +
       

     

       68
       68
       +
       			// if using a handle with @, rewrite to work without @

     

       69
       69
       +
       			if normalized := strings.TrimPrefix(firstPart, "@"); userutil.IsHandle(normalized) {

     

       70
       70
       +
       				redirectPath := strings.Join(append([]string{normalized}, pathParts[1:]...), "/")

     

       71
       71
       +
       

     

       72
       72
       +
       				redirectURL := *r.URL

     

       73
       73
       +
       				redirectURL.Path = "/" + redirectPath

     

       74
       74
       +
       

     

       75
       75
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       76
       76
       +
       				return

     

       77
       77
       +
       			}

     

       78
       78
       +
       

     

       70
       79
        
       		}

     

       80
       80
       +
       

     

       81
       81
       +
       		standardRouter.ServeHTTP(w, r)

     

       71
       82
        
       	})

     

       72
       83
        
       

     

       73
       84
        
       	return router

     
···

       80
       91
        
       		r.Get("/", s.Profile)

     

       81
       92
        
       		r.Get("/feed.atom", s.AtomFeedPage)

     

       82
       93
        
       

     

       83
       83
       -
       		// redirect /@handle/repo.git -> /@handle/repo

     

       84
       84
       -
       		r.Get("/{repo}.git", func(w http.ResponseWriter, r *http.Request) {

     

       85
       85
       -
       			nonDotGitPath := strings.TrimSuffix(r.URL.Path, ".git")

     

       86
       86
       -
       			http.Redirect(w, r, nonDotGitPath, http.StatusMovedPermanently)

     

       87
       87
       -
       		})

     

       88
       88
       -
       

     

       89
       94
        
       		r.With(mw.ResolveRepo()).Route("/{repo}", func(r chi.Router) {

     

       90
       95
        
       			r.Use(mw.GoImport())

     

       91
       96
        
       			r.Mount("/", s.RepoRouter(mw))

     

       92
       97
        
       			r.Mount("/issues", s.IssuesRouter(mw))

     

       93
       98
        
       			r.Mount("/pulls", s.PullsRouter(mw))

     

       94
       94
       -
       			r.Mount("/pipelines", s.PipelinesRouter(mw))

     

       95
       95
       -
       			r.Mount("/labels", s.LabelsRouter(mw))

     

       99
       99
       +
       			r.Mount("/pipelines", s.PipelinesRouter())

     

       100
       100
       +
       			r.Mount("/labels", s.LabelsRouter())

     

       96
       101
        
       

     

       97
       102
        
       			// These routes get proxied to the knot

     

       98
       103
        
       			r.Get("/info/refs", s.InfoRefs)

     
···

       134
       139
        
       		// r.Post("/import", s.ImportRepo)

     

       135
       140
        
       	})

     

       136
       141
        
       

     

       137
       137
       -
       	r.Get("/goodfirstissues", s.GoodFirstIssues)

     

       142
       142
       +
       	r.With(middleware.Paginate).Get("/goodfirstissues", s.GoodFirstIssues)

     

       138
       143
        
       

     

       139
       144
        
       	r.With(middleware.AuthMiddleware(s.oauth)).Route("/follow", func(r chi.Router) {

     

       140
       145
        
       		r.Post("/", s.Follow)

     
···

       161
       166
        
       

     

       162
       167
        
       	r.Mount("/settings", s.SettingsRouter())

     

       163
       168
        
       	r.Mount("/strings", s.StringsRouter(mw))

     

       164
       164
       -
       	r.Mount("/knots", s.KnotsRouter())

     

       165
       165
       -
       	r.Mount("/spindles", s.SpindlesRouter())

     

       169
       169
       +
       

     

       170
       170
       +
       	r.Mount("/settings/knots", s.KnotsRouter())

     

       171
       171
       +
       	r.Mount("/settings/spindles", s.SpindlesRouter())

     

       172
       172
       +
       

     

       166
       173
        
       	r.Mount("/notifications", s.NotificationsRouter(mw))

     

       167
       174
        
       

     

       168
       175
        
       	r.Mount("/signup", s.SignupRouter())

     
···

       256
       263
        
       	issues := issues.New(

     

       257
       264
        
       		s.oauth,

     

       258
       265
        
       		s.repoResolver,

     

       266
       266
       +
       		s.enforcer,

     

       259
       267
        
       		s.pages,

     

       260
       268
        
       		s.idResolver,

     

       269
       269
       +
       		s.mentionsResolver,

     

       261
       270
        
       		s.db,

     

       262
       271
        
       		s.config,

     

       263
       272
        
       		s.notifier,

     

       264
       273
        
       		s.validator,

     

       274
       274
       +
       		s.indexer.Issues,

     

       265
       275
        
       		log.SubLogger(s.logger, "issues"),

     

       266
       276
        
       	)

     

       267
       277
        
       	return issues.Router(mw)

     
···

       273
       283
        
       		s.repoResolver,

     

       274
       284
        
       		s.pages,

     

       275
       285
        
       		s.idResolver,

     

       286
       286
       +
       		s.mentionsResolver,

     

       276
       287
        
       		s.db,

     

       277
       288
        
       		s.config,

     

       278
       289
        
       		s.notifier,

     

       279
       290
        
       		s.enforcer,

     

       280
       291
        
       		s.validator,

     

       292
       292
       +
       		s.indexer.Pulls,

     

       281
       293
        
       		log.SubLogger(s.logger, "pulls"),

     

       282
       294
        
       	)

     

       283
       295
        
       	return pulls.Router(mw)

     
···

       300
       312
        
       	return repo.Router(mw)

     

       301
       313
        
       }

     

       302
       314
        
       

     

       303
       303
       -
       func (s *State) PipelinesRouter(mw *middleware.Middleware) http.Handler {

     

       315
       315
       +
       func (s *State) PipelinesRouter() http.Handler {

     

       304
       316
        
       	pipes := pipelines.New(

     

       305
       317
        
       		s.oauth,

     

       306
       318
        
       		s.repoResolver,

     
···

       312
       324
        
       		s.enforcer,

     

       313
       325
        
       		log.SubLogger(s.logger, "pipelines"),

     

       314
       326
        
       	)

     

       315
       315
       -
       	return pipes.Router(mw)

     

       327
       327
       +
       	return pipes.Router()

     

       316
       328
        
       }

     

       317
       329
        
       

     

       318
       318
       -
       func (s *State) LabelsRouter(mw *middleware.Middleware) http.Handler {

     

       330
       330
       +
       func (s *State) LabelsRouter() http.Handler {

     

       319
       331
        
       	ls := labels.New(

     

       320
       332
        
       		s.oauth,

     

       321
       333
        
       		s.pages,

     
···

       324
       336
        
       		s.enforcer,

     

       325
       337
        
       		log.SubLogger(s.logger, "labels"),

     

       326
       338
        
       	)

     

       327
       327
       -
       	return ls.Router(mw)

     

       339
       339
       +
       	return ls.Router()

     

       328
       340
        
       }

     

       329
       341
        
       

     

       330
       342
        
       func (s *State) NotificationsRouter(mw *middleware.Middleware) http.Handler {

+2 -1

appview/state/spindlestream.go

···

       17
       17
        
       	ec "tangled.org/core/eventconsumer"

     

       18
       18
        
       	"tangled.org/core/eventconsumer/cursor"

     

       19
       19
        
       	"tangled.org/core/log"

     

       20
       20
       +
       	"tangled.org/core/orm"

     

       20
       21
        
       	"tangled.org/core/rbac"

     

       21
       22
        
       	spindle "tangled.org/core/spindle/models"

     

       22
       23
        
       )

     
···

       27
       28
        
       

     

       28
       29
        
       	spindles, err := db.GetSpindles(

     

       29
       30
        
       		d,

     

       30
       30
       -
       		db.FilterIsNot("verified", "null"),

     

       31
       31
       +
       		orm.FilterIsNot("verified", "null"),

     

       31
       32
        
       	)

     

       32
       33
        
       	if err != nil {

     

       33
       34
        
       		return nil, err

+9 -13

appview/state/star.go

···

       57
       57
        
       		log.Println("created atproto record: ", resp.Uri)

     

       58
       58
        
       

     

       59
       59
        
       		star := &models.Star{

     

       60
       60
       -
       			StarredByDid: currentUser.Did,

     

       61
       61
       -
       			RepoAt:       subjectUri,

     

       62
       62
       -
       			Rkey:         rkey,

     

       60
       60
       +
       			Did:    currentUser.Did,

     

       61
       61
       +
       			RepoAt: subjectUri,

     

       62
       62
       +
       			Rkey:   rkey,

     

       63
       63
        
       		}

     

       64
       64
        
       

     

       65
       65
        
       		err = db.AddStar(s.db, star)

     
···

       75
       75
        
       

     

       76
       76
        
       		s.notifier.NewStar(r.Context(), star)

     

       77
       77
        
       

     

       78
       78
       -
       		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{

     

       78
       78
       +
       		s.pages.StarBtnFragment(w, pages.StarBtnFragmentParams{

     

       79
       79
        
       			IsStarred: true,

     

       80
       80
       -
       			RepoAt:    subjectUri,

     

       81
       81
       -
       			Stats: models.RepoStats{

     

       82
       82
       -
       				StarCount: starCount,

     

       83
       83
       -
       			},

     

       80
       80
       +
       			SubjectAt: subjectUri,

     

       81
       81
       +
       			StarCount: starCount,

     

       84
       82
        
       		})

     

       85
       83
        
       

     

       86
       84
        
       		return

     
···

       117
       115
        
       

     

       118
       116
        
       		s.notifier.DeleteStar(r.Context(), star)

     

       119
       117
        
       

     

       120
       120
       -
       		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{

     

       118
       118
       +
       		s.pages.StarBtnFragment(w, pages.StarBtnFragmentParams{

     

       121
       119
        
       			IsStarred: false,

     

       122
       122
       -
       			RepoAt:    subjectUri,

     

       123
       123
       -
       			Stats: models.RepoStats{

     

       124
       124
       -
       				StarCount: starCount,

     

       125
       125
       -
       			},

     

       120
       120
       +
       			SubjectAt: subjectUri,

     

       121
       121
       +
       			StarCount: starCount,

     

       126
       122
        
       		})

     

       127
       123
        
       

     

       128
       124
        
       		return

+50 -34

appview/state/state.go

···

       14
       14
        
       	"tangled.org/core/appview"

     

       15
       15
        
       	"tangled.org/core/appview/config"

     

       16
       16
        
       	"tangled.org/core/appview/db"

     

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

     

       18
       18
       +
       	"tangled.org/core/appview/mentions"

     

       17
       19
        
       	"tangled.org/core/appview/models"

     

       18
       20
        
       	"tangled.org/core/appview/notify"

     

       19
       21
        
       	dbnotify "tangled.org/core/appview/notify/db"

     
···

       28
       30
        
       	"tangled.org/core/jetstream"

     

       29
       31
        
       	"tangled.org/core/log"

     

       30
       32
        
       	tlog "tangled.org/core/log"

     

       33
       33
       +
       	"tangled.org/core/orm"

     

       31
       34
        
       	"tangled.org/core/rbac"

     

       32
       35
        
       	"tangled.org/core/tid"

     

       33
       36
        
       

     
···

       41
       44
        
       )

     

       42
       45
        
       

     

       43
       46
        
       type State struct {

     

       44
       44
       -
       	db            *db.DB

     

       45
       45
       -
       	notifier      notify.Notifier

     

       46
       46
       -
       	oauth         *oauth.OAuth

     

       47
       47
       -
       	enforcer      *rbac.Enforcer

     

       48
       48
       -
       	pages         *pages.Pages

     

       49
       49
       -
       	idResolver    *idresolver.Resolver

     

       50
       50
       -
       	posthog       posthog.Client

     

       51
       51
       -
       	jc            *jetstream.JetstreamClient

     

       52
       52
       -
       	config        *config.Config

     

       53
       53
       -
       	repoResolver  *reporesolver.RepoResolver

     

       54
       54
       -
       	knotstream    *eventconsumer.Consumer

     

       55
       55
       -
       	spindlestream *eventconsumer.Consumer

     

       56
       56
       -
       	logger        *slog.Logger

     

       57
       57
       -
       	validator     *validator.Validator

     

       47
       47
       +
       	db               *db.DB

     

       48
       48
       +
       	notifier         notify.Notifier

     

       49
       49
       +
       	indexer          *indexer.Indexer

     

       50
       50
       +
       	oauth            *oauth.OAuth

     

       51
       51
       +
       	enforcer         *rbac.Enforcer

     

       52
       52
       +
       	pages            *pages.Pages

     

       53
       53
       +
       	idResolver       *idresolver.Resolver

     

       54
       54
       +
       	mentionsResolver *mentions.Resolver

     

       55
       55
       +
       	posthog          posthog.Client

     

       56
       56
       +
       	jc               *jetstream.JetstreamClient

     

       57
       57
       +
       	config           *config.Config

     

       58
       58
       +
       	repoResolver     *reporesolver.RepoResolver

     

       59
       59
       +
       	knotstream       *eventconsumer.Consumer

     

       60
       60
       +
       	spindlestream    *eventconsumer.Consumer

     

       61
       61
       +
       	logger           *slog.Logger

     

       62
       62
       +
       	validator        *validator.Validator

     

       58
       63
        
       }

     

       59
       64
        
       

     

       60
       65
        
       func Make(ctx context.Context, config *config.Config) (*State, error) {

     
···

       65
       70
        
       		return nil, fmt.Errorf("failed to create db: %w", err)

     

       66
       71
        
       	}

     

       67
       72
        
       

     

       73
       73
       +
       	indexer := indexer.New(log.SubLogger(logger, "indexer"))

     

       74
       74
       +
       	err = indexer.Init(ctx, d)

     

       75
       75
       +
       	if err != nil {

     

       76
       76
       +
       		return nil, fmt.Errorf("failed to create indexer: %w", err)

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       68
       79
        
       	enforcer, err := rbac.NewEnforcer(config.Core.DbPath)

     

       69
       80
        
       	if err != nil {

     

       70
       81
        
       		return nil, fmt.Errorf("failed to create enforcer: %w", err)

     

       71
       82
        
       	}

     

       72
       83
        
       

     

       73
       73
       -
       	res, err := idresolver.RedisResolver(config.Redis.ToURL())

     

       84
       84
       +
       	res, err := idresolver.RedisResolver(config.Redis.ToURL(), config.Plc.PLCURL)

     

       74
       85
        
       	if err != nil {

     

       75
       86
        
       		logger.Error("failed to create redis resolver", "err", err)

     

       76
       76
       -
       		res = idresolver.DefaultResolver()

     

       87
       87
       +
       		res = idresolver.DefaultResolver(config.Plc.PLCURL)

     

       77
       88
        
       	}

     

       78
       89
        
       

     

       79
       90
        
       	posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})

     
···

       88
       99
        
       	}

     

       89
       100
        
       	validator := validator.New(d, res, enforcer)

     

       90
       101
        
       

     

       91
       91
       -
       	repoResolver := reporesolver.New(config, enforcer, res, d)

     

       102
       102
       +
       	repoResolver := reporesolver.New(config, enforcer, d)

     

       103
       103
       +
       

     

       104
       104
       +
       	mentionsResolver := mentions.New(config, res, d, log.SubLogger(logger, "mentionsResolver"))

     

       92
       105
        
       

     

       93
       106
        
       	wrapper := db.DbWrapper{Execer: d}

     

       94
       107
        
       	jc, err := jetstream.NewJetstreamClient(

     
···

       121
       134
        
       		return nil, fmt.Errorf("failed to create jetstream client: %w", err)

     

       122
       135
        
       	}

     

       123
       136
        
       

     

       124
       124
       -
       	if err := BackfillDefaultDefs(d, res); err != nil {

     

       137
       137
       +
       	if err := BackfillDefaultDefs(d, res, config.Label.DefaultLabelDefs); err != nil {

     

       125
       138
        
       		return nil, fmt.Errorf("failed to backfill default label defs: %w", err)

     

       126
       139
        
       	}

     

       127
       140
        
       

     
···

       159
       172
        
       	if !config.Core.Dev {

     

       160
       173
        
       		notifiers = append(notifiers, phnotify.NewPosthogNotifier(posthog))

     

       161
       174
        
       	}

     

       162
       162
       -
       	notifier := notify.NewMergedNotifier(notifiers...)

     

       175
       175
       +
       	notifiers = append(notifiers, indexer)

     

       176
       176
       +
       	notifier := notify.NewMergedNotifier(notifiers, tlog.SubLogger(logger, "notify"))

     

       163
       177
        
       

     

       164
       178
        
       	state := &State{

     

       165
       179
        
       		d,

     

       166
       180
        
       		notifier,

     

       181
       181
       +
       		indexer,

     

       167
       182
        
       		oauth,

     

       168
       183
        
       		enforcer,

     

       169
       184
        
       		pages,

     

       170
       185
        
       		res,

     

       186
       186
       +
       		mentionsResolver,

     

       171
       187
        
       		posthog,

     

       172
       188
        
       		jc,

     

       173
       189
        
       		config,

     
···

       284
       300
        
       		return

     

       285
       301
        
       	}

     

       286
       302
        
       

     

       287
       287
       -
       	gfiLabel, err := db.GetLabelDefinition(s.db, db.FilterEq("at_uri", models.LabelGoodFirstIssue))

     

       303
       303
       +
       	gfiLabel, err := db.GetLabelDefinition(s.db, orm.FilterEq("at_uri", s.config.Label.GoodFirstIssue))

     

       288
       304
        
       	if err != nil {

     

       289
       305
        
       		// non-fatal

     

       290
       306
        
       	}

     
···

       308
       324
        
       

     

       309
       325
        
       	regs, err := db.GetRegistrations(

     

       310
       326
        
       		s.db,

     

       311
       311
       -
       		db.FilterEq("did", user.Did),

     

       312
       312
       -
       		db.FilterEq("needs_upgrade", 1),

     

       327
       327
       +
       		orm.FilterEq("did", user.Did),

     

       328
       328
       +
       		orm.FilterEq("needs_upgrade", 1),

     

       313
       329
        
       	)

     

       314
       330
        
       	if err != nil {

     

       315
       331
        
       		l.Error("non-fatal: failed to get registrations", "err", err)

     
···

       317
       333
        
       

     

       318
       334
        
       	spindles, err := db.GetSpindles(

     

       319
       335
        
       		s.db,

     

       320
       320
       -
       		db.FilterEq("owner", user.Did),

     

       321
       321
       -
       		db.FilterEq("needs_upgrade", 1),

     

       336
       336
       +
       		orm.FilterEq("owner", user.Did),

     

       337
       337
       +
       		orm.FilterEq("needs_upgrade", 1),

     

       322
       338
        
       	)

     

       323
       339
        
       	if err != nil {

     

       324
       340
        
       		l.Error("non-fatal: failed to get spindles", "err", err)

     
···

       376
       392
        
       

     

       377
       393
        
       	pubKeys, err := db.GetPublicKeysForDid(s.db, id.DID.String())

     

       378
       394
        
       	if err != nil {

     

       379
       379
       -
       		w.WriteHeader(http.StatusNotFound)

     

       395
       395
       +
       		s.logger.Error("failed to get public keys", "err", err)

     

       396
       396
       +
       		http.Error(w, "failed to get public keys", http.StatusInternalServerError)

     

       380
       397
        
       		return

     

       381
       398
        
       	}

     

       382
       399
        
       

     

       383
       400
        
       	if len(pubKeys) == 0 {

     

       384
       384
       -
       		w.WriteHeader(http.StatusNotFound)

     

       401
       401
       +
       		w.WriteHeader(http.StatusNoContent)

     

       385
       402
        
       		return

     

       386
       403
        
       	}

     

       387
       404
        
       

     
···

       488
       505
        
       		// Check for existing repos

     

       489
       506
        
       		existingRepo, err := db.GetRepo(

     

       490
       507
        
       			s.db,

     

       491
       491
       -
       			db.FilterEq("did", user.Did),

     

       492
       492
       -
       			db.FilterEq("name", repoName),

     

       508
       508
       +
       			orm.FilterEq("did", user.Did),

     

       509
       509
       +
       			orm.FilterEq("name", repoName),

     

       493
       510
        
       		)

     

       494
       511
        
       		if err == nil && existingRepo != nil {

     

       495
       512
        
       			l.Info("repo exists")

     
···

       506
       523
        
       			Rkey:        rkey,

     

       507
       524
        
       			Description: description,

     

       508
       525
        
       			Created:     time.Now(),

     

       509
       509
       -
       			Labels:      models.DefaultLabelDefs(),

     

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

     

       510
       527
        
       		}

     

       511
       528
        
       		record := repo.AsRecord()

     

       512
       529
        
       

     
···

       622
       639
        
       		aturi = ""

     

       623
       640
        
       

     

       624
       641
        
       		s.notifier.NewRepo(r.Context(), repo)

     

       625
       625
       -
       		s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s", user.Did, repoName))

     

       642
       642
       +
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/%s", user.Did, repoName))

     

       626
       643
        
       	}

     

       627
       644
        
       }

     

       628
       645
        
       

     
···

       648
       665
        
       	return err

     

       649
       666
        
       }

     

       650
       667
        
       

     

       651
       651
       -
       func BackfillDefaultDefs(e db.Execer, r *idresolver.Resolver) error {

     

       652
       652
       -
       	defaults := models.DefaultLabelDefs()

     

       653
       653
       -
       	defaultLabels, err := db.GetLabelDefinitions(e, db.FilterIn("at_uri", defaults))

     

       668
       668
       +
       func BackfillDefaultDefs(e db.Execer, r *idresolver.Resolver, defaults []string) error {

     

       669
       669
       +
       	defaultLabels, err := db.GetLabelDefinitions(e, orm.FilterIn("at_uri", defaults))

     

       654
       670
        
       	if err != nil {

     

       655
       671
        
       		return err

     

       656
       672
        
       	}

     
···

       659
       675
        
       		return nil

     

       660
       676
        
       	}

     

       661
       677
        
       

     

       662
       662
       -
       	labelDefs, err := models.FetchDefaultDefs(r)

     

       678
       678
       +
       	labelDefs, err := models.FetchLabelDefs(r, defaults)

     

       663
       679
        
       	if err != nil {

     

       664
       680
        
       		return err

     

       665
       681
        
       	}

+6 -6

appview/state/userutil/userutil.go

···

       10
       10
        
       	didRegex    = regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)

     

       11
       11
        
       )

     

       12
       12
        
       

     

       13
       13
       -
       func IsHandleNoAt(s string) bool {

     

       13
       13
       +
       func IsHandle(s string) bool {

     

       14
       14
        
       	// ref: https://atproto.com/specs/handle

     

       15
       15
        
       	return handleRegex.MatchString(s)

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       // IsDid checks if the given string is a standard DID.

     

       19
       19
       +
       func IsDid(s string) bool {

     

       20
       20
       +
       	return didRegex.MatchString(s)

     

       16
       21
        
       }

     

       17
       22
        
       

     

       18
       23
        
       func UnflattenDid(s string) string {

     
···

       45
       50
        
       		return strings.Replace(s, ":", "-", 2)

     

       46
       51
        
       	}

     

       47
       52
        
       	return s

     

       48
       48
       -
       }

     

       49
       49
       -
       

     

       50
       50
       -
       // IsDid checks if the given string is a standard DID.

     

       51
       51
       -
       func IsDid(s string) bool {

     

       52
       52
       -
       	return didRegex.MatchString(s)

     

       53
       53
        
       }

     

       54
       54
        
       

     

       55
       55
        
       var subdomainRegex = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]{2,61}[a-z0-9])?$`)

+21 -8

appview/strings/strings.go

···

       17
       17
        
       	"tangled.org/core/appview/pages"

     

       18
       18
        
       	"tangled.org/core/appview/pages/markup"

     

       19
       19
        
       	"tangled.org/core/idresolver"

     

       20
       20
       +
       	"tangled.org/core/orm"

     

       20
       21
        
       	"tangled.org/core/tid"

     

       21
       22
        
       

     

       22
       23
        
       	"github.com/bluesky-social/indigo/api/atproto"

     
···

       108
       109
        
       	strings, err := db.GetStrings(

     

       109
       110
        
       		s.Db,

     

       110
       111
        
       		0,

     

       111
       111
       -
       		db.FilterEq("did", id.DID),

     

       112
       112
       -
       		db.FilterEq("rkey", rkey),

     

       112
       112
       +
       		orm.FilterEq("did", id.DID),

     

       113
       113
       +
       		orm.FilterEq("rkey", rkey),

     

       113
       114
        
       	)

     

       114
       115
        
       	if err != nil {

     

       115
       116
        
       		l.Error("failed to fetch string", "err", err)

     
···

       148
       149
        
       		showRendered = r.URL.Query().Get("code") != "true"

     

       149
       150
        
       	}

     

       150
       151
        
       

     

       152
       152
       +
       	starCount, err := db.GetStarCount(s.Db, string.AtUri())

     

       153
       153
       +
       	if err != nil {

     

       154
       154
       +
       		l.Error("failed to get star count", "err", err)

     

       155
       155
       +
       	}

     

       156
       156
       +
       	user := s.OAuth.GetUser(r)

     

       157
       157
       +
       	isStarred := false

     

       158
       158
       +
       	if user != nil {

     

       159
       159
       +
       		isStarred = db.GetStarStatus(s.Db, user.Did, string.AtUri())

     

       160
       160
       +
       	}

     

       161
       161
       +
       

     

       151
       162
        
       	s.Pages.SingleString(w, pages.SingleStringParams{

     

       152
       152
       -
       		LoggedInUser: s.OAuth.GetUser(r),

     

       163
       163
       +
       		LoggedInUser: user,

     

       153
       164
        
       		RenderToggle: renderToggle,

     

       154
       165
        
       		ShowRendered: showRendered,

     

       155
       155
       -
       		String:       string,

     

       166
       166
       +
       		String:       &string,

     

       156
       167
        
       		Stats:        string.Stats(),

     

       168
       168
       +
       		IsStarred:    isStarred,

     

       169
       169
       +
       		StarCount:    starCount,

     

       157
       170
        
       		Owner:        id,

     

       158
       171
        
       	})

     

       159
       172
        
       }

     
···

       187
       200
        
       	all, err := db.GetStrings(

     

       188
       201
        
       		s.Db,

     

       189
       202
        
       		0,

     

       190
       190
       -
       		db.FilterEq("did", id.DID),

     

       191
       191
       -
       		db.FilterEq("rkey", rkey),

     

       203
       203
       +
       		orm.FilterEq("did", id.DID),

     

       204
       204
       +
       		orm.FilterEq("rkey", rkey),

     

       192
       205
        
       	)

     

       193
       206
        
       	if err != nil {

     

       194
       207
        
       		l.Error("failed to fetch string", "err", err)

     
···

       396
       409
        
       

     

       397
       410
        
       	if err := db.DeleteString(

     

       398
       411
        
       		s.Db,

     

       399
       399
       -
       		db.FilterEq("did", user.Did),

     

       400
       400
       -
       		db.FilterEq("rkey", rkey),

     

       412
       412
       +
       		orm.FilterEq("did", user.Did),

     

       413
       413
       +
       		orm.FilterEq("rkey", rkey),

     

       401
       414
        
       	); err != nil {

     

       402
       415
        
       		fail("Failed to delete string.", err)

     

       403
       416
        
       		return

+2 -1

appview/validator/issue.go

···

       6
       6
        
       

     

       7
       7
        
       	"tangled.org/core/appview/db"

     

       8
       8
        
       	"tangled.org/core/appview/models"

     

       9
       9
       +
       	"tangled.org/core/orm"

     

       9
       10
        
       )

     

       10
       11
        
       

     

       11
       12
        
       func (v *Validator) ValidateIssueComment(comment *models.IssueComment) error {

     

       12
       13
        
       	// if comments have parents, only ingest ones that are 1 level deep

     

       13
       14
        
       	if comment.ReplyTo != nil {

     

       14
       14
       -
       		parents, err := db.GetIssueComments(v.db, db.FilterEq("at_uri", *comment.ReplyTo))

     

       15
       15
       +
       		parents, err := db.GetIssueComments(v.db, orm.FilterEq("at_uri", *comment.ReplyTo))

     

       15
       16
        
       		if err != nil {

     

       16
       17
        
       			return fmt.Errorf("failed to fetch parent comment: %w", err)

     

       17
       18
        
       		}

+53

appview/validator/repo_topics.go

···

       1
       1
       +
       package validator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"maps"

     

       6
       6
       +
       	"regexp"

     

       7
       7
       +
       	"slices"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       const (

     

       12
       12
       +
       	maxTopicLen = 50

     

       13
       13
       +
       	maxTopics   = 20

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       var (

     

       17
       17
       +
       	topicRE = regexp.MustCompile(`\A[a-z0-9-]+\z`)

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       // ValidateRepoTopicStr parses and validates whitespace-separated topic string.

     

       21
       21
       +
       //

     

       22
       22
       +
       // Rules:

     

       23
       23
       +
       //   - topics are separated by whitespace

     

       24
       24
       +
       //   - each topic may contain lowercase letters, digits, and hyphens only

     

       25
       25
       +
       //   - each topic must be <= 50 characters long

     

       26
       26
       +
       //   - no more than 20 topics allowed

     

       27
       27
       +
       //   - duplicates are removed

     

       28
       28
       +
       func (v *Validator) ValidateRepoTopicStr(topicsStr string) ([]string, error) {

     

       29
       29
       +
       	topicsStr = strings.TrimSpace(topicsStr)

     

       30
       30
       +
       	if topicsStr == "" {

     

       31
       31
       +
       		return nil, nil

     

       32
       32
       +
       	}

     

       33
       33
       +
       	parts := strings.Fields(topicsStr)

     

       34
       34
       +
       	if len(parts) > maxTopics {

     

       35
       35
       +
       		return nil, fmt.Errorf("too many topics: %d (maximum %d)", len(parts), maxTopics)

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	topicSet := make(map[string]struct{})

     

       39
       39
       +
       

     

       40
       40
       +
       	for _, t := range parts {

     

       41
       41
       +
       		if _, exists := topicSet[t]; exists {

     

       42
       42
       +
       			continue

     

       43
       43
       +
       		}

     

       44
       44
       +
       		if len(t) > maxTopicLen {

     

       45
       45
       +
       			return nil, fmt.Errorf("topic '%s' is too long (maximum %d characters)", t, maxTopics)

     

       46
       46
       +
       		}

     

       47
       47
       +
       		if !topicRE.MatchString(t) {

     

       48
       48
       +
       			return nil, fmt.Errorf("topic '%s' contains invalid characters (allowed: lowercase letters, digits, hyphens)", t)

     

       49
       49
       +
       		}

     

       50
       50
       +
       		topicSet[t] = struct{}{}

     

       51
       51
       +
       	}

     

       52
       52
       +
       	return slices.Collect(maps.Keys(topicSet)), nil

     

       53
       53
       +
       }

+17

appview/validator/uri.go

···

       1
       1
       +
       package validator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net/url"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       func (v *Validator) ValidateURI(uri string) error {

     

       9
       9
       +
       	parsed, err := url.Parse(uri)

     

       10
       10
       +
       	if err != nil {

     

       11
       11
       +
       		return fmt.Errorf("invalid uri format")

     

       12
       12
       +
       	}

     

       13
       13
       +
       	if parsed.Scheme == "" {

     

       14
       14
       +
       		return fmt.Errorf("uri scheme missing")

     

       15
       15
       +
       	}

     

       16
       16
       +
       	return nil

     

       17
       17
       +
       }

-43

cmd/genjwks/main.go

···

       1
       1
       -
       // adapted from https://tangled.org/anirudh.fi/atproto-oauth

     

       2
       2
       -
       

     

       3
       3
       -
       package main

     

       4
       4
       -
       

     

       5
       5
       -
       import (

     

       6
       6
       -
       	"crypto/ecdsa"

     

       7
       7
       -
       	"crypto/elliptic"

     

       8
       8
       -
       	"crypto/rand"

     

       9
       9
       -
       	"encoding/json"

     

       10
       10
       -
       	"fmt"

     

       11
       11
       -
       	"time"

     

       12
       12
       -
       

     

       13
       13
       -
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       14
       14
       -
       )

     

       15
       15
       -
       

     

       16
       16
       -
       func main() {

     

       17
       17
       -
       	privKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

     

       18
       18
       -
       	if err != nil {

     

       19
       19
       -
       		panic(err)

     

       20
       20
       -
       	}

     

       21
       21
       -
       

     

       22
       22
       -
       	key, err := jwk.FromRaw(privKey)

     

       23
       23
       -
       	if err != nil {

     

       24
       24
       -
       		panic(err)

     

       25
       25
       -
       	}

     

       26
       26
       -
       

     

       27
       27
       -
       	kid := fmt.Sprintf("%d", time.Now().Unix())

     

       28
       28
       -
       

     

       29
       29
       -
       	if err := key.Set(jwk.KeyIDKey, kid); err != nil {

     

       30
       30
       -
       		panic(err)

     

       31
       31
       -
       	}

     

       32
       32
       -
       

     

       33
       33
       -
       	if err := key.Set("use", "sig"); err != nil {

     

       34
       34
       -
       		panic(err)

     

       35
       35
       -
       	}

     

       36
       36
       -
       

     

       37
       37
       -
       	b, err := json.Marshal(key)

     

       38
       38
       -
       	if err != nil {

     

       39
       39
       -
       		panic(err)

     

       40
       40
       -
       	}

     

       41
       41
       -
       

     

       42
       42
       -
       	fmt.Println(string(b))

     

       43
       43
       -
       }

+1 -34

crypto/verify.go

···

       5
       5
        
       	"crypto/sha256"

     

       6
       6
        
       	"encoding/base64"

     

       7
       7
        
       	"fmt"

     

       8
       8
       -
       	"strings"

     

       9
       8
        
       

     

       10
       9
        
       	"github.com/hiddeco/sshsig"

     

       11
       10
        
       	"golang.org/x/crypto/ssh"

     

       12
       12
       -
       	"tangled.org/core/types"

     

       13
       11
        
       )

     

       14
       12
        
       

     

       15
       13
        
       func VerifySignature(pubKey, signature, payload []byte) (error, bool) {

     
···

       28
       26
        
       	// multiple algorithms but sha-512 is most secure, and git's ssh signing defaults

     

       29
       27
        
       	// to sha-512 for all key types anyway.

     

       30
       28
        
       	err = sshsig.Verify(buf, sig, pub, sshsig.HashSHA512, "git")

     

       31
       31
       -
       	return err, err == nil

     

       32
       32
       -
       }

     

       33
       29
        
       

     

       34
       34
       -
       // VerifyCommitSignature reconstructs the payload used to sign a commit. This is

     

       35
       35
       -
       // essentially the git cat-file output but without the gpgsig header.

     

       36
       36
       -
       //

     

       37
       37
       -
       // Caveats: signature verification will fail on commits with more than one parent,

     

       38
       38
       -
       // i.e. merge commits, because types.NiceDiff doesn't carry more than one Parent field

     

       39
       39
       -
       // and we are unable to reconstruct the payload correctly.

     

       40
       40
       -
       //

     

       41
       41
       -
       // Ideally this should directly operate on an *object.Commit.

     

       42
       42
       -
       func VerifyCommitSignature(pubKey string, commit types.NiceDiff) (error, bool) {

     

       43
       43
       -
       	signature := commit.Commit.PGPSignature

     

       44
       44
       -
       

     

       45
       45
       -
       	author := bytes.NewBuffer([]byte{})

     

       46
       46
       -
       	committer := bytes.NewBuffer([]byte{})

     

       47
       47
       -
       	commit.Commit.Author.Encode(author)

     

       48
       48
       -
       	commit.Commit.Committer.Encode(committer)

     

       49
       49
       -
       

     

       50
       50
       -
       	payload := strings.Builder{}

     

       51
       51
       -
       

     

       52
       52
       -
       	fmt.Fprintf(&payload, "tree %s\n", commit.Commit.Tree)

     

       53
       53
       -
       	if commit.Commit.Parent != "" {

     

       54
       54
       -
       		fmt.Fprintf(&payload, "parent %s\n", commit.Commit.Parent)

     

       55
       55
       -
       	}

     

       56
       56
       -
       	fmt.Fprintf(&payload, "author %s\n", author.String())

     

       57
       57
       -
       	fmt.Fprintf(&payload, "committer %s\n", committer.String())

     

       58
       58
       -
       	if commit.Commit.ChangedId != "" {

     

       59
       59
       -
       		fmt.Fprintf(&payload, "change-id %s\n", commit.Commit.ChangedId)

     

       60
       60
       -
       	}

     

       61
       61
       -
       	fmt.Fprintf(&payload, "\n%s", commit.Commit.Message)

     

       62
       62
       -
       

     

       63
       63
       -
       	return VerifySignature([]byte(pubKey), []byte(signature), []byte(payload.String()))

     

       30
       30
       +
       	return err, err == nil

     

       64
       31
        
       }

     

       65
       32
        
       

     

       66
       33
        
       // SSHFingerprint computes the fingerprint of the supplied ssh pubkey.

+19 -9

docs/hacking.md

···

       37
       37
        
       

     

       38
       38
        
       ```

     

       39
       39
        
       # oauth jwks should already be setup by the nix devshell:

     

       40
       40
       -
       echo $TANGLED_OAUTH_JWKS

     

       41
       41
       -
       {"crv":"P-256","d":"tELKHYH-Dko6qo4ozYcVPE1ah6LvXHFV2wpcWpi8ab4","kid":"1753352226","kty":"EC","x":"mRzYpLzAGq74kJez9UbgGfV040DxgsXpMbaVsdy8RZs","y":"azqqXzUYywMlLb2Uc5AVG18nuLXyPnXr4kI4T39eeIc"}

     

       40
       40
       +
       echo $TANGLED_OAUTH_CLIENT_SECRET

     

       41
       41
       +
       z42ty4RT1ovnTopY8B8ekz9NuziF2CuMkZ7rbRFpAR9jBqMc

     

       42
       42
       +
       

     

       43
       43
       +
       echo $TANGLED_OAUTH_CLIENT_KID

     

       44
       44
       +
       1761667908

     

       42
       45
        
       

     

       43
       46
        
       # if not, you can set it up yourself:

     

       44
       44
       -
       go build -o genjwks.out ./cmd/genjwks

     

       45
       45
       -
       export TANGLED_OAUTH_JWKS="$(./genjwks.out)"

     

       47
       47
       +
       goat key generate -t P-256

     

       48
       48
       +
       Key Type: P-256 / secp256r1 / ES256 private key

     

       49
       49
       +
       Secret Key (Multibase Syntax): save this securely (eg, add to password manager)

     

       50
       50
       +
               z42tuPDKRfM2mz2Kv953ARen2jmrPA8S9LX9tRq4RVcUMwwL

     

       51
       51
       +
       Public Key (DID Key Syntax): share or publish this (eg, in DID document)

     

       52
       52
       +
               did:key:zDnaeUBxtG6Xuv3ATJE4GaWeyXM3jyamJsZw3bSPpxx4bNXDR

     

       53
       53
       +
       

     

       54
       54
       +
       # the secret key from above

     

       55
       55
       +
       export TANGLED_OAUTH_CLIENT_SECRET="z42tuP..."

     

       46
       56
        
       

     

       47
       57
        
       # run redis in at a new shell to store oauth sessions

     

       48
       58
        
       redis-server

     
···

       107
       117
        
       # type `poweroff` at the shell to exit the VM

     

       108
       118
        
       ```

     

       109
       119
        
       

     

       110
       110
       -
       This starts a knot on port 6000, a spindle on port 6555

     

       120
       120
       +
       This starts a knot on port 6444, a spindle on port 6555

     

       111
       121
        
       with `ssh` exposed on port 2222.

     

       112
       122
        
       

     

       113
       123
        
       Once the services are running, head to

     

       114
       114
       -
       http://localhost:3000/knots and hit verify. It should

     

       124
       124
       +
       http://localhost:3000/settings/knots and hit verify. It should

     

       115
       125
        
       verify the ownership of the services instantly if everything

     

       116
       126
        
       went smoothly.

     

       117
       127
        
       

     
···

       136
       146
        
       ### running a spindle

     

       137
       147
        
       

     

       138
       148
        
       The above VM should already be running a spindle on

     

       139
       139
       -
       `localhost:6555`. Head to http://localhost:3000/spindles and

     

       149
       149
       +
       `localhost:6555`. Head to http://localhost:3000/settings/spindles and

     

       140
       150
        
       hit verify. You can then configure each repository to use

     

       141
       151
        
       this spindle and run CI jobs.

     

       142
       152
        
       

     
···

       158
       168
        
       

     

       159
       169
        
       If for any reason you wish to disable either one of the

     

       160
       170
        
       services in the VM, modify [nix/vm.nix](/nix/vm.nix) and set

     

       161
       161
       -
       `services.tangled-spindle.enable` (or

     

       162
       162
       -
       `services.tangled-knot.enable`) to `false`.

     

       171
       171
       +
       `services.tangled.spindle.enable` (or

     

       172
       172
       +
       `services.tangled.knot.enable`) to `false`.

+1 -1

docs/knot-hosting.md

···

       131
       131
        
       

     

       132
       132
        
       You should now have a running knot server! You can finalize

     

       133
       133
        
       your registration by hitting the `verify` button on the

     

       134
       134
       -
       [/knots](https://tangled.org/knots) page. This simply creates

     

       134
       134
       +
       [/settings/knots](https://tangled.org/settings/knots) page. This simply creates

     

       135
       135
        
       a record on your PDS to announce the existence of the knot.

     

       136
       136
        
       

     

       137
       137
        
       ### custom paths

+4 -4

docs/migrations.md

···

       14
       14
        
       For knots:

     

       15
       15
        
       

     

       16
       16
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       17
       17
       -
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       17
       17
       +
       - Head to the [knot dashboard](https://tangled.org/settings/knots) and

     

       18
       18
        
         hit the "retry" button to verify your knot

     

       19
       19
        
       

     

       20
       20
        
       For spindles:

     

       21
       21
        
       

     

       22
       22
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       23
       23
        
       - Head to the [spindle

     

       24
       24
       -
         dashboard](https://tangled.org/spindles) and hit the

     

       24
       24
       +
         dashboard](https://tangled.org/settings/spindles) and hit the

     

       25
       25
        
         "retry" button to verify your spindle

     

       26
       26
        
       

     

       27
       27
        
       ## Upgrading from v1.7.x

     
···

       41
       41
        
         [settings](https://tangled.org/settings) page.

     

       42
       42
        
       - Restart your knot once you have replaced the environment

     

       43
       43
        
         variable

     

       44
       44
       -
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       44
       44
       +
       - Head to the [knot dashboard](https://tangled.org/settings/knots) and

     

       45
       45
        
         hit the "retry" button to verify your knot. This simply

     

       46
       46
        
         writes a `sh.tangled.knot` record to your PDS.

     

       47
       47
        
       

     
···

       49
       49
        
       latest revision, and change your config block like so:

     

       50
       50
        
       

     

       51
       51
        
       ```diff

     

       52
       52
       -
        services.tangled-knot = {

     

       52
       52
       +
        services.tangled.knot = {

     

       53
       53
        
          enable = true;

     

       54
       54
        
          server = {

     

       55
       55
        
       -    secretFile = /path/to/secret;

+19 -1

docs/spindle/pipeline.md

···

       19
       19
        
         - `push`: The workflow should run every time a commit is pushed to the repository.

     

       20
       20
        
         - `pull_request`: The workflow should run every time a pull request is made or updated.

     

       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.

     

       22
       22
       +
       - `branch`: 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. Supports glob patterns using `*` and `**` (e.g., `main`, `develop`, `release-*`). Either `branch` or `tag` (or both) must be specified for `push` events.

     

       23
       23
       +
       - `tag`: Defines which tags the workflow should run for. Only used with the `push` event - when tags matching the pattern(s) listed here are pushed, the workflow will trigger. This field has no effect with `pull_request` or `manual` events. Supports glob patterns using `*` and `**` (e.g., `v*`, `v1.*`, `release-**`). Either `branch` or `tag` (or both) must be specified for `push` events.

     

       23
       24
        
       

     

       24
       25
        
       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
       26
        
       

     
···

       29
       30
        
           branch: ["main", "develop"]

     

       30
       31
        
         - event: ["pull_request"]

     

       31
       32
        
           branch: ["main"]

     

       33
       33
       +
       ```

     

       34
       34
       +
       

     

       35
       35
       +
       You can also trigger workflows on tag pushes. For instance, to run a deployment workflow when tags matching `v*` are pushed:

     

       36
       36
       +
       

     

       37
       37
       +
       ```yaml

     

       38
       38
       +
       when:

     

       39
       39
       +
         - event: ["push"]

     

       40
       40
       +
           tag: ["v*"]

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       You can even combine branch and tag patterns in a single constraint (the workflow triggers if either matches):

     

       44
       44
       +
       

     

       45
       45
       +
       ```yaml

     

       46
       46
       +
       when:

     

       47
       47
       +
         - event: ["push"]

     

       48
       48
       +
           branch: ["main", "release-*"]

     

       49
       49
       +
           tag: ["v*", "stable"]

     

       32
       50
        
       ```

     

       33
       51
        
       

     

       34
       52
        
       ## Engine

+20 -3

flake.lock

···

       1
       1
        
       {

     

       2
       2
        
         "nodes": {

     

       3
       3
       +
           "actor-typeahead-src": {

     

       4
       4
       +
             "flake": false,

     

       5
       5
       +
             "locked": {

     

       6
       6
       +
               "lastModified": 1762835797,

     

       7
       7
       +
               "narHash": "sha256-heizoWUKDdar6ymfZTnj3ytcEv/L4d4fzSmtr0HlXsQ=",

     

       8
       8
       +
               "ref": "refs/heads/main",

     

       9
       9
       +
               "rev": "677fe7f743050a4e7f09d4a6f87bbf1325a06f6b",

     

       10
       10
       +
               "revCount": 6,

     

       11
       11
       +
               "type": "git",

     

       12
       12
       +
               "url": "https://tangled.org/@jakelazaroff.com/actor-typeahead"

     

       13
       13
       +
             },

     

       14
       14
       +
             "original": {

     

       15
       15
       +
               "type": "git",

     

       16
       16
       +
               "url": "https://tangled.org/@jakelazaroff.com/actor-typeahead"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       3
       19
        
           "flake-compat": {

     

       4
       20
        
             "flake": false,

     

       5
       21
        
             "locked": {

     
···

       134
       150
        
           },

     

       135
       151
        
           "nixpkgs": {

     

       136
       152
        
             "locked": {

     

       137
       137
       -
               "lastModified": 1751984180,

     

       138
       138
       -
               "narHash": "sha256-LwWRsENAZJKUdD3SpLluwDmdXY9F45ZEgCb0X+xgOL0=",

     

       153
       153
       +
               "lastModified": 1765186076,

     

       154
       154
       +
               "narHash": "sha256-hM20uyap1a0M9d344I692r+ik4gTMyj60cQWO+hAYP8=",

     

       139
       155
        
               "owner": "nixos",

     

       140
       156
        
               "repo": "nixpkgs",

     

       141
       141
       -
               "rev": "9807714d6944a957c2e036f84b0ff8caf9930bc0",

     

       157
       157
       +
               "rev": "addf7cf5f383a3101ecfba091b98d0a1263dc9b8",

     

       142
       158
        
               "type": "github"

     

       143
       159
        
             },

     

       144
       160
        
             "original": {

     
···

       150
       166
        
           },

     

       151
       167
        
           "root": {

     

       152
       168
        
             "inputs": {

     

       169
       169
       +
               "actor-typeahead-src": "actor-typeahead-src",

     

       153
       170
        
               "flake-compat": "flake-compat",

     

       154
       171
        
               "gomod2nix": "gomod2nix",

     

       155
       172
        
               "htmx-src": "htmx-src",

+21 -16

flake.nix

···

       33
       33
        
             url = "https://github.com/rsms/inter/releases/download/v4.1/Inter-4.1.zip";

     

       34
       34
        
             flake = false;

     

       35
       35
        
           };

     

       36
       36
       +
           actor-typeahead-src = {

     

       37
       37
       +
             url = "git+https://tangled.org/@jakelazaroff.com/actor-typeahead";

     

       38
       38
       +
             flake = false;

     

       39
       39
       +
           };

     

       36
       40
        
           ibm-plex-mono-src = {

     

       37
       41
        
             url = "https://github.com/IBM/plex/releases/download/%40ibm%2Fplex-mono%401.1.0/ibm-plex-mono.zip";

     

       38
       42
        
             flake = false;

     
···

       54
       58
        
           inter-fonts-src,

     

       55
       59
        
           sqlite-lib-src,

     

       56
       60
        
           ibm-plex-mono-src,

     

       61
       61
       +
           actor-typeahead-src,

     

       57
       62
        
           ...

     

       58
       63
        
         }: let

     

       59
       64
        
           supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"];

     
···

       75
       80
        
                 }).buildGoApplication;

     

       76
       81
        
               modules = ./nix/gomod2nix.toml;

     

       77
       82
        
               sqlite-lib = self.callPackage ./nix/pkgs/sqlite-lib.nix {

     

       78
       78
       -
                 inherit (pkgs) gcc;

     

       79
       83
        
                 inherit sqlite-lib-src;

     

       80
       84
        
               };

     

       81
       81
       -
               genjwks = self.callPackage ./nix/pkgs/genjwks.nix {};

     

       82
       85
        
               lexgen = self.callPackage ./nix/pkgs/lexgen.nix {inherit indigo;};

     

       86
       86
       +
               goat = self.callPackage ./nix/pkgs/goat.nix {inherit indigo;};

     

       83
       87
        
               appview-static-files = self.callPackage ./nix/pkgs/appview-static-files.nix {

     

       84
       84
       -
                 inherit htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src;

     

       88
       88
       +
                 inherit htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src actor-typeahead-src;

     

       85
       89
        
               };

     

       86
       90
        
               appview = self.callPackage ./nix/pkgs/appview.nix {};

     

       87
       91
        
               spindle = self.callPackage ./nix/pkgs/spindle.nix {};

     
···

       90
       94
        
             });

     

       91
       95
        
         in {

     

       92
       96
        
           overlays.default = final: prev: {

     

       93
       93
       -
             inherit (mkPackageSet final) lexgen sqlite-lib genjwks spindle knot-unwrapped knot appview;

     

       97
       97
       +
             inherit (mkPackageSet final) lexgen goat sqlite-lib spindle knot-unwrapped knot appview;

     

       94
       98
        
           };

     

       95
       99
        
       

     

       96
       100
        
           packages = forAllSystems (system: let

     
···

       99
       103
        
             staticPackages = mkPackageSet pkgs.pkgsStatic;

     

       100
       104
        
             crossPackages = mkPackageSet pkgs.pkgsCross.gnu64.pkgsStatic;

     

       101
       105
        
           in {

     

       102
       102
       -
             inherit (packages) appview appview-static-files lexgen genjwks spindle knot knot-unwrapped sqlite-lib;

     

       106
       106
       +
             inherit (packages) appview appview-static-files lexgen goat spindle knot knot-unwrapped sqlite-lib;

     

       103
       107
        
       

     

       104
       108
        
             pkgsStatic-appview = staticPackages.appview;

     

       105
       109
        
             pkgsStatic-knot = staticPackages.knot;

     
···

       151
       155
        
               nativeBuildInputs = [

     

       152
       156
        
                 pkgs.go

     

       153
       157
        
                 pkgs.air

     

       154
       154
       -
                 pkgs.tilt

     

       155
       158
        
                 pkgs.gopls

     

       156
       159
        
                 pkgs.httpie

     

       157
       160
        
                 pkgs.litecli

     
···

       167
       170
        
                 mkdir -p appview/pages/static

     

       168
       171
        
                 # no preserve is needed because watch-tailwind will want to be able to overwrite

     

       169
       172
        
                 cp -fr --no-preserve=ownership ${packages'.appview-static-files}/* appview/pages/static

     

       170
       170
       -
                 export TANGLED_OAUTH_JWKS="$(${packages'.genjwks}/bin/genjwks)"

     

       173
       173
       +
                 export TANGLED_OAUTH_CLIENT_KID="$(date +%s)"

     

       174
       174
       +
                 export TANGLED_OAUTH_CLIENT_SECRET="$(${packages'.goat}/bin/goat key generate -t P-256 | grep -A1 "Secret Key" | tail -n1 | awk '{print $1}')"

     

       171
       175
        
               '';

     

       172
       176
        
               env.CGO_ENABLED = 1;

     

       173
       177
        
             };

     
···

       178
       182
        
             air-watcher = name: arg:

     

       179
       183
        
               pkgs.writeShellScriptBin "run"

     

       180
       184
        
               ''

     

       181
       181
       -
                 ${pkgs.air}/bin/air -c /dev/null \

     

       182
       182
       -
                 -build.cmd "${pkgs.go}/bin/go build -o ./out/${name}.out ./cmd/${name}/main.go" \

     

       183
       183
       -
                 -build.bin "./out/${name}.out" \

     

       184
       184
       -
                 -build.args_bin "${arg}" \

     

       185
       185
       -
                 -build.stop_on_error "true" \

     

       186
       186
       -
                 -build.include_ext "go"

     

       185
       185
       +
                 export PATH=${pkgs.go}/bin:$PATH

     

       186
       186
       +
                 ${pkgs.air}/bin/air -c ./.air/${name}.toml \

     

       187
       187
       +
                   -build.args_bin "${arg}"

     

       187
       188
        
               '';

     

       188
       189
        
             tailwind-watcher =

     

       189
       190
        
               pkgs.writeShellScriptBin "run"

     
···

       206
       207
        
             watch-knot = {

     

       207
       208
        
               type = "app";

     

       208
       209
        
               program = ''${air-watcher "knot" "server"}/bin/run'';

     

       210
       210
       +
             };

     

       211
       211
       +
             watch-spindle = {

     

       212
       212
       +
               type = "app";

     

       213
       213
       +
               program = ''${air-watcher "spindle" ""}/bin/run'';

     

       209
       214
        
             };

     

       210
       215
        
             watch-tailwind = {

     

       211
       216
        
               type = "app";

     
···

       278
       283
        
           }: {

     

       279
       284
        
             imports = [./nix/modules/appview.nix];

     

       280
       285
        
       

     

       281
       281
       -
             services.tangled-appview.package = lib.mkDefault self.packages.${pkgs.system}.appview;

     

       286
       286
       +
             services.tangled.appview.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.appview;

     

       282
       287
        
           };

     

       283
       288
        
           nixosModules.knot = {

     

       284
       289
        
             lib,

     
···

       287
       292
        
           }: {

     

       288
       293
        
             imports = [./nix/modules/knot.nix];

     

       289
       294
        
       

     

       290
       290
       -
             services.tangled-knot.package = lib.mkDefault self.packages.${pkgs.system}.knot;

     

       295
       295
       +
             services.tangled.knot.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.knot;

     

       291
       296
        
           };

     

       292
       297
        
           nixosModules.spindle = {

     

       293
       298
        
             lib,

     
···

       296
       301
        
           }: {

     

       297
       302
        
             imports = [./nix/modules/spindle.nix];

     

       298
       303
        
       

     

       299
       299
       -
             services.tangled-spindle.package = lib.mkDefault self.packages.${pkgs.system}.spindle;

     

       304
       304
       +
             services.tangled.spindle.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.spindle;

     

       300
       305
        
           };

     

       301
       306
        
         };

     

       302
       307
        
       }

+31 -14

go.mod

···

       1
       1
        
       module tangled.org/core

     

       2
       2
        
       

     

       3
       3
       -
       go 1.24.4

     

       3
       3
       +
       go 1.25.0

     

       4
       4
        
       

     

       5
       5
        
       require (

     

       6
       6
        
       	github.com/Blank-Xu/sql-adapter v1.1.1

     

       7
       7
        
       	github.com/alecthomas/assert/v2 v2.11.0

     

       8
       8
        
       	github.com/alecthomas/chroma/v2 v2.15.0

     

       9
       9
        
       	github.com/avast/retry-go/v4 v4.6.1

     

       10
       10
       +
       	github.com/blevesearch/bleve/v2 v2.5.3

     

       10
       11
        
       	github.com/bluekeyes/go-gitdiff v0.8.1

     

       11
       12
        
       	github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e

     

       12
       13
        
       	github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1

     

       14
       14
       +
       	github.com/bmatcuk/doublestar/v4 v4.9.1

     

       13
       15
        
       	github.com/carlmjohnson/versioninfo v0.22.5

     

       14
       16
        
       	github.com/casbin/casbin/v2 v2.103.0

     

       17
       17
       +
       	github.com/charmbracelet/log v0.4.2

     

       15
       18
        
       	github.com/cloudflare/cloudflare-go v0.115.0

     

       16
       19
        
       	github.com/cyphar/filepath-securejoin v0.4.1

     

       17
       20
        
       	github.com/dgraph-io/ristretto v0.2.0

     
···

       29
       32
        
       	github.com/hiddeco/sshsig v0.2.0

     

       30
       33
        
       	github.com/hpcloud/tail v1.0.0

     

       31
       34
        
       	github.com/ipfs/go-cid v0.5.0

     

       32
       32
       -
       	github.com/lestrrat-go/jwx/v2 v2.1.6

     

       33
       35
        
       	github.com/mattn/go-sqlite3 v1.14.24

     

       34
       36
        
       	github.com/microcosm-cc/bluemonday v1.0.27

     

       35
       37
        
       	github.com/openbao/openbao/api/v2 v2.3.0

     
···

       42
       44
        
       	github.com/stretchr/testify v1.10.0

     

       43
       45
        
       	github.com/urfave/cli/v3 v3.3.3

     

       44
       46
        
       	github.com/whyrusleeping/cbor-gen v0.3.1

     

       45
       45
       -
       	github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57

     

       46
       47
        
       	github.com/yuin/goldmark v1.7.13

     

       47
       48
        
       	github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc

     

       49
       49
       +
       	gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab

     

       48
       50
        
       	golang.org/x/crypto v0.40.0

     

       49
       51
        
       	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b

     

       50
       52
        
       	golang.org/x/image v0.31.0

     
···

       58
       60
        
       	dario.cat/mergo v1.0.1 // indirect

     

       59
       61
        
       	github.com/Microsoft/go-winio v0.6.2 // indirect

     

       60
       62
        
       	github.com/ProtonMail/go-crypto v1.3.0 // indirect

     

       63
       63
       +
       	github.com/RoaringBitmap/roaring/v2 v2.4.5 // indirect

     

       61
       64
        
       	github.com/alecthomas/repr v0.4.0 // indirect

     

       62
       65
        
       	github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect

     

       63
       66
        
       	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect

     

       64
       67
        
       	github.com/aymerick/douceur v0.2.0 // indirect

     

       65
       68
        
       	github.com/beorn7/perks v1.0.1 // indirect

     

       66
       66
       -
       	github.com/bmatcuk/doublestar/v4 v4.7.1 // indirect

     

       69
       69
       +
       	github.com/bits-and-blooms/bitset v1.22.0 // indirect

     

       70
       70
       +
       	github.com/blevesearch/bleve_index_api v1.2.8 // indirect

     

       71
       71
       +
       	github.com/blevesearch/geo v0.2.4 // indirect

     

       72
       72
       +
       	github.com/blevesearch/go-faiss v1.0.25 // indirect

     

       73
       73
       +
       	github.com/blevesearch/go-porterstemmer v1.0.3 // indirect

     

       74
       74
       +
       	github.com/blevesearch/gtreap v0.1.1 // indirect

     

       75
       75
       +
       	github.com/blevesearch/mmap-go v1.0.4 // indirect

     

       76
       76
       +
       	github.com/blevesearch/scorch_segment_api/v2 v2.3.10 // indirect

     

       77
       77
       +
       	github.com/blevesearch/segment v0.9.1 // indirect

     

       78
       78
       +
       	github.com/blevesearch/snowballstem v0.9.0 // indirect

     

       79
       79
       +
       	github.com/blevesearch/upsidedown_store_api v1.0.2 // indirect

     

       80
       80
       +
       	github.com/blevesearch/vellum v1.1.0 // indirect

     

       81
       81
       +
       	github.com/blevesearch/zapx/v11 v11.4.2 // indirect

     

       82
       82
       +
       	github.com/blevesearch/zapx/v12 v12.4.2 // indirect

     

       83
       83
       +
       	github.com/blevesearch/zapx/v13 v13.4.2 // indirect

     

       84
       84
       +
       	github.com/blevesearch/zapx/v14 v14.4.2 // indirect

     

       85
       85
       +
       	github.com/blevesearch/zapx/v15 v15.4.2 // indirect

     

       86
       86
       +
       	github.com/blevesearch/zapx/v16 v16.2.4 // indirect

     

       67
       87
        
       	github.com/casbin/govaluate v1.3.0 // indirect

     

       68
       88
        
       	github.com/cenkalti/backoff/v4 v4.3.0 // indirect

     

       69
       89
        
       	github.com/cespare/xxhash/v2 v2.3.0 // indirect

     

       70
       90
        
       	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect

     

       71
       91
        
       	github.com/charmbracelet/lipgloss v1.1.0 // indirect

     

       72
       72
       -
       	github.com/charmbracelet/log v0.4.2 // indirect

     

       73
       92
        
       	github.com/charmbracelet/x/ansi v0.8.0 // indirect

     

       74
       93
        
       	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect

     

       75
       94
        
       	github.com/charmbracelet/x/term v0.2.1 // indirect

     
···

       78
       97
        
       	github.com/containerd/errdefs/pkg v0.3.0 // indirect

     

       79
       98
        
       	github.com/containerd/log v0.1.0 // indirect

     

       80
       99
        
       	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect

     

       81
       81
       -
       	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect

     

       82
       100
        
       	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect

     

       83
       101
        
       	github.com/distribution/reference v0.6.0 // indirect

     

       84
       102
        
       	github.com/dlclark/regexp2 v1.11.5 // indirect

     
···

       101
       119
        
       	github.com/golang-jwt/jwt/v5 v5.2.3 // indirect

     

       102
       120
        
       	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect

     

       103
       121
        
       	github.com/golang/mock v1.6.0 // indirect

     

       122
       122
       +
       	github.com/golang/protobuf v1.5.4 // indirect

     

       123
       123
       +
       	github.com/golang/snappy v0.0.4 // indirect

     

       104
       124
        
       	github.com/google/go-querystring v1.1.0 // indirect

     

       105
       125
        
       	github.com/gorilla/css v1.0.1 // indirect

     

       106
       126
        
       	github.com/gorilla/securecookie v1.1.2 // indirect

     
···

       126
       146
        
       	github.com/ipfs/go-log v1.0.5 // indirect

     

       127
       147
        
       	github.com/ipfs/go-log/v2 v2.6.0 // indirect

     

       128
       148
        
       	github.com/ipfs/go-metrics-interface v0.3.0 // indirect

     

       149
       149
       +
       	github.com/json-iterator/go v1.1.12 // indirect

     

       129
       150
        
       	github.com/kevinburke/ssh_config v1.2.0 // indirect

     

       130
       151
        
       	github.com/klauspost/compress v1.18.0 // indirect

     

       131
       152
        
       	github.com/klauspost/cpuid/v2 v2.3.0 // indirect

     

       132
       132
       -
       	github.com/lestrrat-go/blackmagic v1.0.4 // indirect

     

       133
       133
       -
       	github.com/lestrrat-go/httpcc v1.0.1 // indirect

     

       134
       134
       -
       	github.com/lestrrat-go/httprc v1.0.6 // indirect

     

       135
       135
       -
       	github.com/lestrrat-go/iter v1.0.2 // indirect

     

       136
       136
       -
       	github.com/lestrrat-go/option v1.0.1 // indirect

     

       137
       153
        
       	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect

     

       138
       154
        
       	github.com/mattn/go-isatty v0.0.20 // indirect

     

       139
       155
        
       	github.com/mattn/go-runewidth v0.0.16 // indirect

     
···

       142
       158
        
       	github.com/moby/docker-image-spec v1.3.1 // indirect

     

       143
       159
        
       	github.com/moby/sys/atomicwriter v0.1.0 // indirect

     

       144
       160
        
       	github.com/moby/term v0.5.2 // indirect

     

       161
       161
       +
       	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect

     

       162
       162
       +
       	github.com/modern-go/reflect2 v1.0.2 // indirect

     

       145
       163
        
       	github.com/morikuni/aec v1.0.0 // indirect

     

       146
       164
        
       	github.com/mr-tron/base58 v1.2.0 // indirect

     

       165
       165
       +
       	github.com/mschoch/smat v0.2.0 // indirect

     

       147
       166
        
       	github.com/muesli/termenv v0.16.0 // indirect

     

       148
       167
        
       	github.com/multiformats/go-base32 v0.1.0 // indirect

     

       149
       168
        
       	github.com/multiformats/go-base36 v0.2.0 // indirect

     
···

       165
       184
        
       	github.com/prometheus/procfs v0.16.1 // indirect

     

       166
       185
        
       	github.com/rivo/uniseg v0.4.7 // indirect

     

       167
       186
        
       	github.com/ryanuber/go-glob v1.0.0 // indirect

     

       168
       168
       -
       	github.com/segmentio/asm v1.2.0 // indirect

     

       169
       187
        
       	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect

     

       170
       188
        
       	github.com/spaolacci/murmur3 v1.1.0 // indirect

     

       171
       189
        
       	github.com/vmihailenco/go-tinylfu v0.2.2 // indirect

     

       172
       190
        
       	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect

     

       173
       191
        
       	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect

     

       174
       174
       -
       	github.com/wyatt915/treeblood v0.1.15 // indirect

     

       175
       192
        
       	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect

     

       176
       176
       -
       	gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab // indirect

     

       177
       193
        
       	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect

     

       178
       194
        
       	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect

     

       195
       195
       +
       	go.etcd.io/bbolt v1.4.0 // indirect

     

       179
       196
        
       	go.opentelemetry.io/auto/sdk v1.1.0 // indirect

     

       180
       197
        
       	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 // indirect

     

       181
       198
        
       	go.opentelemetry.io/otel v1.37.0 // indirect

+60 -21

go.sum

···

       9
       9
        
       github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=

     

       10
       10
        
       github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw=

     

       11
       11
        
       github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE=

     

       12
       12
       +
       github.com/RoaringBitmap/roaring/v2 v2.4.5 h1:uGrrMreGjvAtTBobc0g5IrW1D5ldxDQYe2JW2gggRdg=

     

       13
       13
       +
       github.com/RoaringBitmap/roaring/v2 v2.4.5/go.mod h1:FiJcsfkGje/nZBZgCu0ZxCPOKD/hVXDS2dXi7/eUFE0=

     

       12
       14
        
       github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=

     

       13
       15
        
       github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=

     

       14
       16
        
       github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=

     
···

       25
       27
        
       github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=

     

       26
       28
        
       github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=

     

       27
       29
        
       github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=

     

       30
       30
       +
       github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=

     

       31
       31
       +
       github.com/bits-and-blooms/bitset v1.22.0 h1:Tquv9S8+SGaS3EhyA+up3FXzmkhxPGjQQCkcs2uw7w4=

     

       32
       32
       +
       github.com/bits-and-blooms/bitset v1.22.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=

     

       33
       33
       +
       github.com/blevesearch/bleve/v2 v2.5.3 h1:9l1xtKaETv64SZc1jc4Sy0N804laSa/LeMbYddq1YEM=

     

       34
       34
       +
       github.com/blevesearch/bleve/v2 v2.5.3/go.mod h1:Z/e8aWjiq8HeX+nW8qROSxiE0830yQA071dwR3yoMzw=

     

       35
       35
       +
       github.com/blevesearch/bleve_index_api v1.2.8 h1:Y98Pu5/MdlkRyLM0qDHostYo7i+Vv1cDNhqTeR4Sy6Y=

     

       36
       36
       +
       github.com/blevesearch/bleve_index_api v1.2.8/go.mod h1:rKQDl4u51uwafZxFrPD1R7xFOwKnzZW7s/LSeK4lgo0=

     

       37
       37
       +
       github.com/blevesearch/geo v0.2.4 h1:ECIGQhw+QALCZaDcogRTNSJYQXRtC8/m8IKiA706cqk=

     

       38
       38
       +
       github.com/blevesearch/geo v0.2.4/go.mod h1:K56Q33AzXt2YExVHGObtmRSFYZKYGv0JEN5mdacJJR8=

     

       39
       39
       +
       github.com/blevesearch/go-faiss v1.0.25 h1:lel1rkOUGbT1CJ0YgzKwC7k+XH0XVBHnCVWahdCXk4U=

     

       40
       40
       +
       github.com/blevesearch/go-faiss v1.0.25/go.mod h1:OMGQwOaRRYxrmeNdMrXJPvVx8gBnvE5RYrr0BahNnkk=

     

       41
       41
       +
       github.com/blevesearch/go-porterstemmer v1.0.3 h1:GtmsqID0aZdCSNiY8SkuPJ12pD4jI+DdXTAn4YRcHCo=

     

       42
       42
       +
       github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M=

     

       43
       43
       +
       github.com/blevesearch/gtreap v0.1.1 h1:2JWigFrzDMR+42WGIN/V2p0cUvn4UP3C4Q5nmaZGW8Y=

     

       44
       44
       +
       github.com/blevesearch/gtreap v0.1.1/go.mod h1:QaQyDRAT51sotthUWAH4Sj08awFSSWzgYICSZ3w0tYk=

     

       45
       45
       +
       github.com/blevesearch/mmap-go v1.0.4 h1:OVhDhT5B/M1HNPpYPBKIEJaD0F3Si+CrEKULGCDPWmc=

     

       46
       46
       +
       github.com/blevesearch/mmap-go v1.0.4/go.mod h1:EWmEAOmdAS9z/pi/+Toxu99DnsbhG1TIxUoRmJw/pSs=

     

       47
       47
       +
       github.com/blevesearch/scorch_segment_api/v2 v2.3.10 h1:Yqk0XD1mE0fDZAJXTjawJ8If/85JxnLd8v5vG/jWE/s=

     

       48
       48
       +
       github.com/blevesearch/scorch_segment_api/v2 v2.3.10/go.mod h1:Z3e6ChN3qyN35yaQpl00MfI5s8AxUJbpTR/DL8QOQ+8=

     

       49
       49
       +
       github.com/blevesearch/segment v0.9.1 h1:+dThDy+Lvgj5JMxhmOVlgFfkUtZV2kw49xax4+jTfSU=

     

       50
       50
       +
       github.com/blevesearch/segment v0.9.1/go.mod h1:zN21iLm7+GnBHWTao9I+Au/7MBiL8pPFtJBJTsk6kQw=

     

       51
       51
       +
       github.com/blevesearch/snowballstem v0.9.0 h1:lMQ189YspGP6sXvZQ4WZ+MLawfV8wOmPoD/iWeNXm8s=

     

       52
       52
       +
       github.com/blevesearch/snowballstem v0.9.0/go.mod h1:PivSj3JMc8WuaFkTSRDW2SlrulNWPl4ABg1tC/hlgLs=

     

       53
       53
       +
       github.com/blevesearch/upsidedown_store_api v1.0.2 h1:U53Q6YoWEARVLd1OYNc9kvhBMGZzVrdmaozG2MfoB+A=

     

       54
       54
       +
       github.com/blevesearch/upsidedown_store_api v1.0.2/go.mod h1:M01mh3Gpfy56Ps/UXHjEO/knbqyQ1Oamg8If49gRwrQ=

     

       55
       55
       +
       github.com/blevesearch/vellum v1.1.0 h1:CinkGyIsgVlYf8Y2LUQHvdelgXr6PYuvoDIajq6yR9w=

     

       56
       56
       +
       github.com/blevesearch/vellum v1.1.0/go.mod h1:QgwWryE8ThtNPxtgWJof5ndPfx0/YMBh+W2weHKPw8Y=

     

       57
       57
       +
       github.com/blevesearch/zapx/v11 v11.4.2 h1:l46SV+b0gFN+Rw3wUI1YdMWdSAVhskYuvxlcgpQFljs=

     

       58
       58
       +
       github.com/blevesearch/zapx/v11 v11.4.2/go.mod h1:4gdeyy9oGa/lLa6D34R9daXNUvfMPZqUYjPwiLmekwc=

     

       59
       59
       +
       github.com/blevesearch/zapx/v12 v12.4.2 h1:fzRbhllQmEMUuAQ7zBuMvKRlcPA5ESTgWlDEoB9uQNE=

     

       60
       60
       +
       github.com/blevesearch/zapx/v12 v12.4.2/go.mod h1:TdFmr7afSz1hFh/SIBCCZvcLfzYvievIH6aEISCte58=

     

       61
       61
       +
       github.com/blevesearch/zapx/v13 v13.4.2 h1:46PIZCO/ZuKZYgxI8Y7lOJqX3Irkc3N8W82QTK3MVks=

     

       62
       62
       +
       github.com/blevesearch/zapx/v13 v13.4.2/go.mod h1:knK8z2NdQHlb5ot/uj8wuvOq5PhDGjNYQQy0QDnopZk=

     

       63
       63
       +
       github.com/blevesearch/zapx/v14 v14.4.2 h1:2SGHakVKd+TrtEqpfeq8X+So5PShQ5nW6GNxT7fWYz0=

     

       64
       64
       +
       github.com/blevesearch/zapx/v14 v14.4.2/go.mod h1:rz0XNb/OZSMjNorufDGSpFpjoFKhXmppH9Hi7a877D8=

     

       65
       65
       +
       github.com/blevesearch/zapx/v15 v15.4.2 h1:sWxpDE0QQOTjyxYbAVjt3+0ieu8NCE0fDRaFxEsp31k=

     

       66
       66
       +
       github.com/blevesearch/zapx/v15 v15.4.2/go.mod h1:1pssev/59FsuWcgSnTa0OeEpOzmhtmr/0/11H0Z8+Nw=

     

       67
       67
       +
       github.com/blevesearch/zapx/v16 v16.2.4 h1:tGgfvleXTAkwsD5mEzgM3zCS/7pgocTCnO1oyAUjlww=

     

       68
       68
       +
       github.com/blevesearch/zapx/v16 v16.2.4/go.mod h1:Rti/REtuuMmzwsI8/C/qIzRaEoSK/wiFYw5e5ctUKKs=

     

       28
       69
        
       github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e h1:IutKPwmbU0LrYqw03EuwJtMdAe67rDTrL1U8S8dicRU=

     

       29
       70
        
       github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e/go.mod h1:n6QE1NDPFoi7PRbMUZmc2y7FibCqiVU4ePpsvhHUBR8=

     

       30
       71
        
       github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1 h1:CFvRtYNSnWRAi/98M3O466t9dYuwtesNbu6FVPymRrA=

     

       31
       72
        
       github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1/go.mod h1:WiYEeyJSdUwqoaZ71KJSpTblemUCpwJfh5oVXplK6T4=

     

       32
       73
        
       github.com/bmatcuk/doublestar/v4 v4.6.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       33
       33
       -
       github.com/bmatcuk/doublestar/v4 v4.7.1 h1:fdDeAqgT47acgwd9bd9HxJRDmc9UAmPpc+2m0CXv75Q=

     

       34
       74
        
       github.com/bmatcuk/doublestar/v4 v4.7.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       75
       75
       +
       github.com/bmatcuk/doublestar/v4 v4.9.1 h1:X8jg9rRZmJd4yRy7ZeNDRnM+T3ZfHv15JiBJ/avrEXE=

     

       76
       76
       +
       github.com/bmatcuk/doublestar/v4 v4.9.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=

     

       35
       77
        
       github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=

     

       36
       78
        
       github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=

     

       37
       79
        
       github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=

     
···

       83
       125
        
       github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       84
       126
        
       github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=

     

       85
       127
        
       github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       86
       86
       -
       github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=

     

       87
       87
       -
       github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=

     

       88
       128
        
       github.com/dgraph-io/ristretto v0.2.0 h1:XAfl+7cmoUDWW/2Lx8TGZQjjxIQ2Ley9DSf52dru4WE=

     

       89
       129
        
       github.com/dgraph-io/ristretto v0.2.0/go.mod h1:8uBHCU/PBV4Ag0CJrP47b9Ofby5dqWNh4FicAdoqFNU=

     

       90
       130
        
       github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=

     
···

       170
       210
        
       github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=

     

       171
       211
        
       github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=

     

       172
       212
        
       github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=

     

       213
       213
       +
       github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=

     

       214
       214
       +
       github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=

     

       215
       215
       +
       github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=

     

       216
       216
       +
       github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=

     

       173
       217
        
       github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=

     

       174
       218
        
       github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=

     

       175
       219
        
       github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=

     
···

       181
       225
        
       github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=

     

       182
       226
        
       github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=

     

       183
       227
        
       github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=

     

       228
       228
       +
       github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=

     

       184
       229
        
       github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=

     

       185
       230
        
       github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=

     

       186
       231
        
       github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=

     
···

       261
       306
        
       github.com/ipfs/go-log/v2 v2.6.0/go.mod h1:p+Efr3qaY5YXpx9TX7MoLCSEZX5boSWj9wh86P5HJa8=

     

       262
       307
        
       github.com/ipfs/go-metrics-interface v0.3.0 h1:YwG7/Cy4R94mYDUuwsBfeziJCVm9pBMJ6q/JR9V40TU=

     

       263
       308
        
       github.com/ipfs/go-metrics-interface v0.3.0/go.mod h1:OxxQjZDGocXVdyTPocns6cOLwHieqej/jos7H4POwoY=

     

       309
       309
       +
       github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=

     

       310
       310
       +
       github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=

     

       264
       311
        
       github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=

     

       265
       312
        
       github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=

     

       266
       313
        
       github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=

     
···

       280
       327
        
       github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

     

       281
       328
        
       github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=

     

       282
       329
        
       github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=

     

       283
       283
       -
       github.com/lestrrat-go/blackmagic v1.0.4 h1:IwQibdnf8l2KoO+qC3uT4OaTWsW7tuRQXy9TRN9QanA=

     

       284
       284
       -
       github.com/lestrrat-go/blackmagic v1.0.4/go.mod h1:6AWFyKNNj0zEXQYfTMPfZrAXUWUfTIZ5ECEUEJaijtw=

     

       285
       285
       -
       github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE=

     

       286
       286
       -
       github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E=

     

       287
       287
       -
       github.com/lestrrat-go/httprc v1.0.6 h1:qgmgIRhpvBqexMJjA/PmwSvhNk679oqD1RbovdCGW8k=

     

       288
       288
       -
       github.com/lestrrat-go/httprc v1.0.6/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo=

     

       289
       289
       -
       github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI=

     

       290
       290
       -
       github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4=

     

       291
       291
       -
       github.com/lestrrat-go/jwx/v2 v2.1.6 h1:hxM1gfDILk/l5ylers6BX/Eq1m/pnxe9NBwW6lVfecA=

     

       292
       292
       -
       github.com/lestrrat-go/jwx/v2 v2.1.6/go.mod h1:Y722kU5r/8mV7fYDifjug0r8FK8mZdw0K0GpJw/l8pU=

     

       293
       293
       -
       github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU=

     

       294
       294
       -
       github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I=

     

       295
       330
        
       github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=

     

       296
       331
        
       github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=

     

       297
       332
        
       github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=

     
···

       316
       351
        
       github.com/moby/sys/sequential v0.6.0/go.mod h1:uyv8EUTrca5PnDsdMGXhZe6CCe8U/UiTWd+lL+7b/Ko=

     

       317
       352
        
       github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=

     

       318
       353
        
       github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=

     

       354
       354
       +
       github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=

     

       355
       355
       +
       github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=

     

       356
       356
       +
       github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=

     

       357
       357
       +
       github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=

     

       358
       358
       +
       github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=

     

       319
       359
        
       github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=

     

       320
       360
        
       github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=

     

       321
       361
        
       github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=

     

       322
       362
        
       github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=

     

       363
       363
       +
       github.com/mschoch/smat v0.2.0 h1:8imxQsjDm8yFEAVBe7azKmKSgzSkZXDuKkSq9374khM=

     

       364
       364
       +
       github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw=

     

       323
       365
        
       github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=

     

       324
       366
        
       github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=

     

       325
       367
        
       github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE=

     
···

       409
       451
        
       github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

     

       410
       452
        
       github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk=

     

       411
       453
        
       github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=

     

       412
       412
       -
       github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

     

       413
       413
       -
       github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs=

     

       414
       454
        
       github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=

     

       415
       455
        
       github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=

     

       416
       456
        
       github.com/sethvargo/go-envconfig v1.1.0 h1:cWZiJxeTm7AlCvzGXrEXaSTCNgip5oJepekh/BOQuog=

     
···

       455
       495
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=

     

       456
       496
        
       github.com/whyrusleeping/cbor-gen v0.3.1 h1:82ioxmhEYut7LBVGhGq8xoRkXPLElVuh5mV67AFfdv0=

     

       457
       497
        
       github.com/whyrusleeping/cbor-gen v0.3.1/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=

     

       458
       458
       -
       github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57 h1:UqtQdzLXnvdBdqn/go53qGyncw1wJ7Mq5SQdieM1/Ew=

     

       459
       459
       -
       github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57/go.mod h1:BxSCWByWSRSuembL3cDG1IBUbkBoO/oW/6tF19aA4hs=

     

       460
       460
       -
       github.com/wyatt915/treeblood v0.1.15 h1:3KZ3o2LpcKZAzOLqMoW9qeUzKEaKArKpbcPpTkNfQC8=

     

       461
       461
       -
       github.com/wyatt915/treeblood v0.1.15/go.mod h1:i7+yhhmzdDP17/97pIsOSffw74EK/xk+qJ0029cSXUY=

     

       462
       498
        
       github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=

     

       463
       499
        
       github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=

     

       464
       500
        
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     
···

       477
       513
        
       gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8=

     

       478
       514
        
       gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q=

     

       479
       515
        
       gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02/go.mod h1:JTnUj0mpYiAsuZLmKjTx/ex3AtMowcCgnE7YNyCEP0I=

     

       516
       516
       +
       go.etcd.io/bbolt v1.4.0 h1:TU77id3TnN/zKr7CO/uk+fBCwF2jGcMuw2B/FMAzYIk=

     

       517
       517
       +
       go.etcd.io/bbolt v1.4.0/go.mod h1:AsD+OCi/qPN1giOX1aiLAha3o1U8rAz65bvN4j0sRuk=

     

       480
       518
        
       go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=

     

       481
       519
        
       go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=

     

       482
       520
        
       go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 h1:Hf9xI/XLML9ElpiHVDNwvqI0hIFlzV8dgIr35kV1kRU=

     
···

       680
       718
        
       gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

     

       681
       719
        
       gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=

     

       682
       720
        
       gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       721
       721
       +
       gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       683
       722
        
       gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       684
       723
        
       gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

       685
       724
        
       gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=

+36 -61

guard/guard.go

···

       12
       12
        
       	"os/exec"

     

       13
       13
        
       	"strings"

     

       14
       14
        
       

     

       15
       15
       -
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       16
       15
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       17
       16
        
       	"github.com/urfave/cli/v3"

     

       18
       18
       -
       	"tangled.org/core/idresolver"

     

       19
       17
        
       	"tangled.org/core/log"

     

       20
       18
        
       )

     

       21
       19
        
       

     
···

       93
       91
        
       		"command", sshCommand,

     

       94
       92
        
       		"client", clientIP)

     

       95
       93
        
       

     

       94
       94
       +
       	// TODO: greet user with their resolved handle instead of did

     

       96
       95
        
       	if sshCommand == "" {

     

       97
       96
        
       		l.Info("access denied: no interactive shells", "user", incomingUser)

     

       98
       97
        
       		fmt.Fprintf(os.Stderr, "Hi @%s! You've successfully authenticated.\n", incomingUser)

     
···

       107
       106
        
       	}

     

       108
       107
        
       

     

       109
       108
        
       	gitCommand := cmdParts[0]

     

       110
       110
       -
       

     

       111
       111
       -
       	// did:foo/repo-name or

     

       112
       112
       -
       	// handle/repo-name or

     

       113
       113
       -
       	// any of the above with a leading slash (/)

     

       114
       114
       -
       

     

       115
       115
       -
       	components := strings.Split(strings.TrimPrefix(strings.Trim(cmdParts[1], "'"), "/"), "/")

     

       116
       116
       -
       	l.Info("command components", "components", components)

     

       117
       117
       -
       

     

       118
       118
       -
       	if len(components) != 2 {

     

       119
       119
       -
       		l.Error("invalid repo format", "components", components)

     

       120
       120
       -
       		fmt.Fprintln(os.Stderr, "invalid repo format, needs <user>/<repo> or /<user>/<repo>")

     

       121
       121
       -
       		os.Exit(-1)

     

       122
       122
       -
       	}

     

       123
       123
       -
       

     

       124
       124
       -
       	didOrHandle := components[0]

     

       125
       125
       -
       	identity := resolveIdentity(ctx, l, didOrHandle)

     

       126
       126
       -
       	did := identity.DID.String()

     

       127
       127
       -
       	repoName := components[1]

     

       128
       128
       -
       	qualifiedRepoName, _ := securejoin.SecureJoin(did, repoName)

     

       109
       109
       +
       	repoPath := cmdParts[1]

     

       129
       110
        
       

     

       130
       111
        
       	validCommands := map[string]bool{

     

       131
       112
        
       		"git-receive-pack":   true,

     
···

       138
       119
        
       		return fmt.Errorf("access denied: invalid git command")

     

       139
       120
        
       	}

     

       140
       121
        
       

     

       141
       141
       -
       	if gitCommand != "git-upload-pack" {

     

       142
       142
       -
       		if !isPushPermitted(l, incomingUser, qualifiedRepoName, endpoint) {

     

       143
       143
       -
       			l.Error("access denied: user not allowed",

     

       144
       144
       -
       				"did", incomingUser,

     

       145
       145
       -
       				"reponame", qualifiedRepoName)

     

       146
       146
       -
       			fmt.Fprintln(os.Stderr, "access denied: user not allowed")

     

       147
       147
       -
       			os.Exit(-1)

     

       148
       148
       -
       		}

     

       122
       122
       +
       	// qualify repo path from internal server which holds the knot config

     

       123
       123
       +
       	qualifiedRepoPath, err := guardAndQualifyRepo(l, endpoint, incomingUser, repoPath, gitCommand)

     

       124
       124
       +
       	if err != nil {

     

       125
       125
       +
       		l.Error("failed to run guard", "err", err)

     

       126
       126
       +
       		fmt.Fprintln(os.Stderr, err)

     

       127
       127
       +
       		os.Exit(1)

     

       149
       128
        
       	}

     

       150
       129
        
       

     

       151
       151
       -
       	fullPath, _ := securejoin.SecureJoin(gitDir, qualifiedRepoName)

     

       130
       130
       +
       	fullPath, _ := securejoin.SecureJoin(gitDir, qualifiedRepoPath)

     

       152
       131
        
       

     

       153
       132
        
       	l.Info("processing command",

     

       154
       133
        
       		"user", incomingUser,

     

       155
       134
        
       		"command", gitCommand,

     

       156
       156
       -
       		"repo", repoName,

     

       135
       135
       +
       		"repo", repoPath,

     

       157
       136
        
       		"fullPath", fullPath,

     

       158
       137
        
       		"client", clientIP)

     

       159
       138
        
       

     
···

       177
       156
        
       	gitCmd.Stdin = os.Stdin

     

       178
       157
        
       	gitCmd.Env = append(os.Environ(),

     

       179
       158
        
       		fmt.Sprintf("GIT_USER_DID=%s", incomingUser),

     

       180
       180
       -
       		fmt.Sprintf("GIT_USER_PDS_ENDPOINT=%s", identity.PDSEndpoint()),

     

       181
       159
        
       	)

     

       182
       160
        
       

     

       183
       161
        
       	if err := gitCmd.Run(); err != nil {

     
···

       189
       167
        
       	l.Info("command completed",

     

       190
       168
        
       		"user", incomingUser,

     

       191
       169
        
       		"command", gitCommand,

     

       192
       192
       -
       		"repo", repoName,

     

       170
       170
       +
       		"repo", repoPath,

     

       193
       171
        
       		"success", true)

     

       194
       172
        
       

     

       195
       173
        
       	return nil

     

       196
       174
        
       }

     

       197
       175
        
       

     

       198
       198
       -
       func resolveIdentity(ctx context.Context, l *slog.Logger, didOrHandle string) *identity.Identity {

     

       199
       199
       -
       	resolver := idresolver.DefaultResolver()

     

       200
       200
       -
       	ident, err := resolver.ResolveIdent(ctx, didOrHandle)

     

       176
       176
       +
       // runs guardAndQualifyRepo logic

     

       177
       177
       +
       func guardAndQualifyRepo(l *slog.Logger, endpoint, incomingUser, repo, gitCommand string) (string, error) {

     

       178
       178
       +
       	u, _ := url.Parse(endpoint + "/guard")

     

       179
       179
       +
       	q := u.Query()

     

       180
       180
       +
       	q.Add("user", incomingUser)

     

       181
       181
       +
       	q.Add("repo", repo)

     

       182
       182
       +
       	q.Add("gitCmd", gitCommand)

     

       183
       183
       +
       	u.RawQuery = q.Encode()

     

       184
       184
       +
       

     

       185
       185
       +
       	resp, err := http.Get(u.String())

     

       201
       186
        
       	if err != nil {

     

       202
       202
       -
       		l.Error("Error resolving handle", "error", err, "handle", didOrHandle)

     

       203
       203
       -
       		fmt.Fprintf(os.Stderr, "error resolving handle: %v\n", err)

     

       204
       204
       -
       		os.Exit(1)

     

       205
       205
       -
       	}

     

       206
       206
       -
       	if ident.Handle.IsInvalidHandle() {

     

       207
       207
       -
       		l.Error("Error resolving handle", "invalid handle", didOrHandle)

     

       208
       208
       -
       		fmt.Fprintf(os.Stderr, "error resolving handle: invalid handle\n")

     

       209
       209
       -
       		os.Exit(1)

     

       187
       187
       +
       		return "", err

     

       210
       188
        
       	}

     

       211
       211
       -
       	return ident

     

       212
       212
       -
       }

     

       189
       189
       +
       	defer resp.Body.Close()

     

       213
       190
        
       

     

       214
       214
       -
       func isPushPermitted(l *slog.Logger, user, qualifiedRepoName, endpoint string) bool {

     

       215
       215
       -
       	u, _ := url.Parse(endpoint + "/push-allowed")

     

       216
       216
       -
       	q := u.Query()

     

       217
       217
       -
       	q.Add("user", user)

     

       218
       218
       -
       	q.Add("repo", qualifiedRepoName)

     

       219
       219
       -
       	u.RawQuery = q.Encode()

     

       191
       191
       +
       	l.Info("Running guard", "url", u.String(), "status", resp.Status)

     

       220
       192
        
       

     

       221
       221
       -
       	req, err := http.Get(u.String())

     

       193
       193
       +
       	body, err := io.ReadAll(resp.Body)

     

       222
       194
        
       	if err != nil {

     

       223
       223
       -
       		l.Error("Error verifying permissions", "error", err)

     

       224
       224
       -
       		fmt.Fprintf(os.Stderr, "error verifying permissions: %v\n", err)

     

       225
       225
       -
       		os.Exit(1)

     

       195
       195
       +
       		return "", err

     

       226
       196
        
       	}

     

       227
       227
       -
       

     

       228
       228
       -
       	l.Info("Checking push permission",

     

       229
       229
       -
       		"url", u.String(),

     

       230
       230
       -
       		"status", req.Status)

     

       197
       197
       +
       	text := string(body)

     

       231
       198
        
       

     

       232
       232
       -
       	return req.StatusCode == http.StatusNoContent

     

       199
       199
       +
       	switch resp.StatusCode {

     

       200
       200
       +
       	case http.StatusOK:

     

       201
       201
       +
       		return text, nil

     

       202
       202
       +
       	case http.StatusForbidden:

     

       203
       203
       +
       		l.Error("access denied: user not allowed", "did", incomingUser, "reponame", text)

     

       204
       204
       +
       		return text, errors.New("access denied: user not allowed")

     

       205
       205
       +
       	default:

     

       206
       206
       +
       		return "", errors.New(text)

     

       207
       207
       +
       	}

     

       233
       208
        
       }

+17 -8

idresolver/resolver.go

···

       17
       17
        
       	directory identity.Directory

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
       -
       func BaseDirectory() identity.Directory {

     

       20
       20
       +
       func BaseDirectory(plcUrl string) identity.Directory {

     

       21
       21
        
       	base := identity.BaseDirectory{

     

       22
       22
       -
       		PLCURL: identity.DefaultPLCURL,

     

       22
       22
       +
       		PLCURL: plcUrl,

     

       23
       23
        
       		HTTPClient: http.Client{

     

       24
       24
        
       			Timeout: time.Second * 10,

     

       25
       25
        
       			Transport: &http.Transport{

     
···

       42
       42
        
       	return &base

     

       43
       43
        
       }

     

       44
       44
        
       

     

       45
       45
       -
       func RedisDirectory(url string) (identity.Directory, error) {

     

       45
       45
       +
       func RedisDirectory(url, plcUrl string) (identity.Directory, error) {

     

       46
       46
        
       	hitTTL := time.Hour * 24

     

       47
       47
        
       	errTTL := time.Second * 30

     

       48
       48
        
       	invalidHandleTTL := time.Minute * 5

     

       49
       49
       -
       	return redisdir.NewRedisDirectory(BaseDirectory(), url, hitTTL, errTTL, invalidHandleTTL, 10000)

     

       49
       49
       +
       	return redisdir.NewRedisDirectory(

     

       50
       50
       +
       		BaseDirectory(plcUrl),

     

       51
       51
       +
       		url,

     

       52
       52
       +
       		hitTTL,

     

       53
       53
       +
       		errTTL,

     

       54
       54
       +
       		invalidHandleTTL,

     

       55
       55
       +
       		10000,

     

       56
       56
       +
       	)

     

       50
       57
        
       }

     

       51
       58
        
       

     

       52
       52
       -
       func DefaultResolver() *Resolver {

     

       59
       59
       +
       func DefaultResolver(plcUrl string) *Resolver {

     

       60
       60
       +
       	base := BaseDirectory(plcUrl)

     

       61
       61
       +
       	cached := identity.NewCacheDirectory(base, 250_000, time.Hour*24, time.Minute*2, time.Minute*5)

     

       53
       62
        
       	return &Resolver{

     

       54
       54
       -
       		directory: identity.DefaultDirectory(),

     

       63
       63
       +
       		directory: &cached,

     

       55
       64
        
       	}

     

       56
       65
        
       }

     

       57
       66
        
       

     

       58
       58
       -
       func RedisResolver(redisUrl string) (*Resolver, error) {

     

       59
       59
       -
       	directory, err := RedisDirectory(redisUrl)

     

       67
       67
       +
       func RedisResolver(redisUrl, plcUrl string) (*Resolver, error) {

     

       68
       68
       +
       	directory, err := RedisDirectory(redisUrl, plcUrl)

     

       60
       69
        
       	if err != nil {

     

       61
       70
        
       		return nil, err

     

       62
       71
        
       	}

+38

input.css

···

       161
       161
        
                   @apply no-underline;

     

       162
       162
        
               }

     

       163
       163
        
       

     

       164
       164
       +
               .prose a.mention {

     

       165
       165
       +
                   @apply no-underline hover:underline;

     

       166
       166
       +
               }

     

       167
       167
       +
       

     

       164
       168
        
               .prose li {

     

       165
       169
        
                   @apply my-0 py-0;

     

       166
       170
        
               }

     
···

       241
       245
        
               details[data-callout] > summary::-webkit-details-marker {

     

       242
       246
        
                   display: none;

     

       243
       247
        
               }

     

       248
       248
       +
       

     

       244
       249
        
           }

     

       245
       250
        
           @layer utilities {

     

       246
       251
        
               .error {

     
···

       924
       929
        
               text-decoration: underline;

     

       925
       930
        
           }

     

       926
       931
        
       }

     

       932
       932
       +
       

     

       933
       933
       +
       actor-typeahead {

     

       934
       934
       +
         --color-background: #ffffff;

     

       935
       935
       +
         --color-border: #d1d5db;

     

       936
       936
       +
         --color-shadow: #000000;

     

       937
       937
       +
         --color-hover: #f9fafb;

     

       938
       938
       +
         --color-avatar-fallback: #e5e7eb;

     

       939
       939
       +
         --radius: 0.0;

     

       940
       940
       +
         --padding-menu: 0.0rem;

     

       941
       941
       +
         z-index: 1000;

     

       942
       942
       +
       }

     

       943
       943
       +
       

     

       944
       944
       +
       actor-typeahead::part(handle) {

     

       945
       945
       +
         color: #111827;

     

       946
       946
       +
       }

     

       947
       947
       +
       

     

       948
       948
       +
       actor-typeahead::part(menu) {

     

       949
       949
       +
         box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);

     

       950
       950
       +
       }

     

       951
       951
       +
       

     

       952
       952
       +
       @media (prefers-color-scheme: dark) {

     

       953
       953
       +
         actor-typeahead {

     

       954
       954
       +
           --color-background: #1f2937;

     

       955
       955
       +
           --color-border: #4b5563;

     

       956
       956
       +
           --color-shadow: #000000;

     

       957
       957
       +
           --color-hover: #374151;

     

       958
       958
       +
           --color-avatar-fallback: #4b5563;

     

       959
       959
       +
         }

     

       960
       960
       +
       

     

       961
       961
       +
         actor-typeahead::part(handle) {

     

       962
       962
       +
           color: #f9fafb;

     

       963
       963
       +
         }

     

       964
       964
       +
       }

+15 -4

jetstream/jetstream.go

···

       72
       72
        
       	// existing instances of the closure when j.WantedDids is mutated

     

       73
       73
        
       	return func(ctx context.Context, evt *models.Event) error {

     

       74
       74
        
       

     

       75
       75
       +
       		j.mu.RLock()

     

       75
       76
        
       		// empty filter => all dids allowed

     

       76
       76
       -
       		if len(j.wantedDids) == 0 {

     

       77
       77
       -
       			return processFunc(ctx, evt)

     

       77
       77
       +
       		matches := len(j.wantedDids) == 0

     

       78
       78
       +
       		if !matches {

     

       79
       79
       +
       			if _, ok := j.wantedDids[evt.Did]; ok {

     

       80
       80
       +
       				matches = true

     

       81
       81
       +
       			}

     

       78
       82
        
       		}

     

       83
       83
       +
       		j.mu.RUnlock()

     

       79
       84
        
       

     

       80
       80
       -
       		if _, ok := j.wantedDids[evt.Did]; ok {

     

       85
       85
       +
       		if matches {

     

       81
       86
        
       			return processFunc(ctx, evt)

     

       82
       87
        
       		} else {

     

       83
       88
        
       			return nil

     
···

       122
       127
        
       

     

       123
       128
        
       	go func() {

     

       124
       129
        
       		if j.waitForDid {

     

       125
       125
       -
       			for len(j.wantedDids) == 0 {

     

       130
       130
       +
       			for {

     

       131
       131
       +
       				j.mu.RLock()

     

       132
       132
       +
       				hasDid := len(j.wantedDids) != 0

     

       133
       133
       +
       				j.mu.RUnlock()

     

       134
       134
       +
       				if hasDid {

     

       135
       135
       +
       					break

     

       136
       136
       +
       				}

     

       126
       137
        
       				time.Sleep(time.Second)

     

       127
       138
        
       			}

     

       128
       139
        
       		}

knotserver/config/config.go

···

       19
       19
        
       	InternalListenAddr string `env:"INTERNAL_LISTEN_ADDR, default=127.0.0.1:5444"`

     

       20
       20
        
       	DBPath             string `env:"DB_PATH, default=knotserver.db"`

     

       21
       21
        
       	Hostname           string `env:"HOSTNAME, required"`

     

       22
       22
       +
       	PlcUrl             string `env:"PLC_URL, default=https://plc.directory"`

     

       22
       23
        
       	JetstreamEndpoint  string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       23
       24
        
       	Owner              string `env:"OWNER, required"`

     

       24
       25
        
       	LogDids            bool   `env:"LOG_DIDS, default=true"`

+81

knotserver/db/db.go

···

       1
       1
       +
       package db

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       

     

       9
       9
       +
       	_ "github.com/mattn/go-sqlite3"

     

       10
       10
       +
       	"tangled.org/core/log"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       type DB struct {

     

       14
       14
       +
       	db     *sql.DB

     

       15
       15
       +
       	logger *slog.Logger

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       func Setup(ctx context.Context, dbPath string) (*DB, error) {

     

       19
       19
       +
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       20
       20
       +
       	opts := []string{

     

       21
       21
       +
       		"_foreign_keys=1",

     

       22
       22
       +
       		"_journal_mode=WAL",

     

       23
       23
       +
       		"_synchronous=NORMAL",

     

       24
       24
       +
       		"_auto_vacuum=incremental",

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

       27
       27
       +
       	logger := log.FromContext(ctx)

     

       28
       28
       +
       	logger = log.SubLogger(logger, "db")

     

       29
       29
       +
       

     

       30
       30
       +
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       31
       31
       +
       	if err != nil {

     

       32
       32
       +
       		return nil, err

     

       33
       33
       +
       	}

     

       34
       34
       +
       

     

       35
       35
       +
       	conn, err := db.Conn(ctx)

     

       36
       36
       +
       	if err != nil {

     

       37
       37
       +
       		return nil, err

     

       38
       38
       +
       	}

     

       39
       39
       +
       	defer conn.Close()

     

       40
       40
       +
       

     

       41
       41
       +
       	_, err = conn.ExecContext(ctx, `

     

       42
       42
       +
       		create table if not exists known_dids (

     

       43
       43
       +
       			did text primary key

     

       44
       44
       +
       		);

     

       45
       45
       +
       

     

       46
       46
       +
       		create table if not exists public_keys (

     

       47
       47
       +
       			id integer primary key autoincrement,

     

       48
       48
       +
       			did text not null,

     

       49
       49
       +
       			key text not null,

     

       50
       50
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       51
       51
       +
       			unique(did, key),

     

       52
       52
       +
       			foreign key (did) references known_dids(did) on delete cascade

     

       53
       53
       +
       		);

     

       54
       54
       +
       

     

       55
       55
       +
       		create table if not exists _jetstream (

     

       56
       56
       +
       			id integer primary key autoincrement,

     

       57
       57
       +
       			last_time_us integer not null

     

       58
       58
       +
       		);

     

       59
       59
       +
       

     

       60
       60
       +
       		create table if not exists events (

     

       61
       61
       +
       			rkey text not null,

     

       62
       62
       +
       			nsid text not null,

     

       63
       63
       +
       			event text not null, -- json

     

       64
       64
       +
       			created integer not null default (strftime('%s', 'now')),

     

       65
       65
       +
       			primary key (rkey, nsid)

     

       66
       66
       +
       		);

     

       67
       67
       +
       

     

       68
       68
       +
       		create table if not exists migrations (

     

       69
       69
       +
       			id integer primary key autoincrement,

     

       70
       70
       +
       			name text unique

     

       71
       71
       +
       		);

     

       72
       72
       +
       	`)

     

       73
       73
       +
       	if err != nil {

     

       74
       74
       +
       		return nil, err

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	return &DB{

     

       78
       78
       +
       		db:     db,

     

       79
       79
       +
       		logger: logger,

     

       80
       80
       +
       	}, nil

     

       81
       81
       +
       }

-64

knotserver/db/init.go

···

       1
       1
       -
       package db

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"database/sql"

     

       5
       5
       -
       	"strings"

     

       6
       6
       -
       

     

       7
       7
       -
       	_ "github.com/mattn/go-sqlite3"

     

       8
       8
       -
       )

     

       9
       9
       -
       

     

       10
       10
       -
       type DB struct {

     

       11
       11
       -
       	db *sql.DB

     

       12
       12
       -
       }

     

       13
       13
       -
       

     

       14
       14
       -
       func Setup(dbPath string) (*DB, error) {

     

       15
       15
       -
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       16
       16
       -
       	opts := []string{

     

       17
       17
       -
       		"_foreign_keys=1",

     

       18
       18
       -
       		"_journal_mode=WAL",

     

       19
       19
       -
       		"_synchronous=NORMAL",

     

       20
       20
       -
       		"_auto_vacuum=incremental",

     

       21
       21
       -
       	}

     

       22
       22
       -
       

     

       23
       23
       -
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       24
       24
       -
       	if err != nil {

     

       25
       25
       -
       		return nil, err

     

       26
       26
       -
       	}

     

       27
       27
       -
       

     

       28
       28
       -
       	// NOTE: If any other migration is added here, you MUST

     

       29
       29
       -
       	// copy the pattern in appview: use a single sql.Conn

     

       30
       30
       -
       	// for every migration.

     

       31
       31
       -
       

     

       32
       32
       -
       	_, err = db.Exec(`

     

       33
       33
       -
       		create table if not exists known_dids (

     

       34
       34
       -
       			did text primary key

     

       35
       35
       -
       		);

     

       36
       36
       -
       

     

       37
       37
       -
       		create table if not exists public_keys (

     

       38
       38
       -
       			id integer primary key autoincrement,

     

       39
       39
       -
       			did text not null,

     

       40
       40
       -
       			key text not null,

     

       41
       41
       -
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       42
       42
       -
       			unique(did, key),

     

       43
       43
       -
       			foreign key (did) references known_dids(did) on delete cascade

     

       44
       44
       -
       		);

     

       45
       45
       -
       

     

       46
       46
       -
       		create table if not exists _jetstream (

     

       47
       47
       -
       			id integer primary key autoincrement,

     

       48
       48
       -
       			last_time_us integer not null

     

       49
       49
       -
       		);

     

       50
       50
       -
       

     

       51
       51
       -
       		create table if not exists events (

     

       52
       52
       -
       			rkey text not null,

     

       53
       53
       -
       			nsid text not null,

     

       54
       54
       -
       			event text not null, -- json

     

       55
       55
       -
       			created integer not null default (strftime('%s', 'now')),

     

       56
       56
       -
       			primary key (rkey, nsid)

     

       57
       57
       -
       		);

     

       58
       58
       -
       	`)

     

       59
       59
       -
       	if err != nil {

     

       60
       60
       -
       		return nil, err

     

       61
       61
       -
       	}

     

       62
       62
       -
       

     

       63
       63
       -
       	return &DB{db: db}, nil

     

       64
       64
       -
       }

+1 -17

knotserver/git/diff.go

···

       77
       77
        
       		nd.Diff = append(nd.Diff, ndiff)

     

       78
       78
        
       	}

     

       79
       79
        
       

     

       80
       80
       -
       	nd.Stat.FilesChanged = len(diffs)

     

       81
       81
       -
       	nd.Commit.This = c.Hash.String()

     

       82
       82
       -
       	nd.Commit.PGPSignature = c.PGPSignature

     

       83
       83
       -
       	nd.Commit.Committer = c.Committer

     

       84
       84
       -
       	nd.Commit.Tree = c.TreeHash.String()

     

       85
       85
       -
       

     

       86
       86
       -
       	if parent.Hash.IsZero() {

     

       87
       87
       -
       		nd.Commit.Parent = ""

     

       88
       88
       -
       	} else {

     

       89
       89
       -
       		nd.Commit.Parent = parent.Hash.String()

     

       90
       90
       -
       	}

     

       91
       91
       -
       	nd.Commit.Author = c.Author

     

       92
       92
       -
       	nd.Commit.Message = c.Message

     

       93
       93
       -
       

     

       94
       94
       -
       	if v, ok := c.ExtraHeaders["change-id"]; ok {

     

       95
       95
       -
       		nd.Commit.ChangedId = string(v)

     

       96
       96
       -
       	}

     

       80
       80
       +
       	nd.Commit.FromGoGitCommit(c)

     

       97
       81
        
       

     

       98
       82
        
       	return &nd, nil

     

       99
       83
        
       }

+38 -2

knotserver/git/fork.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"errors"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
       +
       	"net/url"

     

       6
       8
        
       	"os/exec"

     

       9
       9
       +
       	"path/filepath"

     

       7
       10
        
       

     

       8
       11
        
       	"github.com/go-git/go-git/v5"

     

       9
       12
        
       	"github.com/go-git/go-git/v5/config"

     

       13
       13
       +
       	knotconfig "tangled.org/core/knotserver/config"

     

       10
       14
        
       )

     

       11
       15
        
       

     

       12
       12
       -
       func Fork(repoPath, source string) error {

     

       13
       13
       -
       	cloneCmd := exec.Command("git", "clone", "--bare", source, repoPath)

     

       16
       16
       +
       func Fork(repoPath, source string, cfg *knotconfig.Config) error {

     

       17
       17
       +
       	u, err := url.Parse(source)

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		return fmt.Errorf("failed to parse source URL: %w", err)

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	if o := optimizeClone(u, cfg); o != nil {

     

       23
       23
       +
       		u = o

     

       24
       24
       +
       	}

     

       25
       25
       +
       

     

       26
       26
       +
       	cloneCmd := exec.Command("git", "clone", "--bare", u.String(), repoPath)

     

       14
       27
        
       	if err := cloneCmd.Run(); err != nil {

     

       15
       28
        
       		return fmt.Errorf("failed to bare clone repository: %w", err)

     

       16
       29
        
       	}

     
···

       21
       34
        
       	}

     

       22
       35
        
       

     

       23
       36
        
       	return nil

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func optimizeClone(u *url.URL, cfg *knotconfig.Config) *url.URL {

     

       40
       40
       +
       	// only optimize if it's the same host

     

       41
       41
       +
       	if u.Host != cfg.Server.Hostname {

     

       42
       42
       +
       		return nil

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	local := filepath.Join(cfg.Repo.ScanPath, u.Path)

     

       46
       46
       +
       

     

       47
       47
       +
       	// sanity check: is there a git repo there?

     

       48
       48
       +
       	if _, err := PlainOpen(local); err != nil {

     

       49
       49
       +
       		return nil

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	// create optimized file:// URL

     

       53
       53
       +
       	optimized := &url.URL{

     

       54
       54
       +
       		Scheme: "file",

     

       55
       55
       +
       		Path:   local,

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	slog.Debug("performing local clone", "url", optimized.String())

     

       59
       59
       +
       	return optimized

     

       24
       60
        
       }

     

       25
       61
        
       

     

       26
       62
        
       func (g *GitRepo) Sync() error {

+60 -2

knotserver/git/git.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"archive/tar"

     

       5
       5
        
       	"bytes"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"fmt"

     

       7
       8
        
       	"io"

     

       8
       9
        
       	"io/fs"

     
···

       12
       13
        
       	"time"

     

       13
       14
        
       

     

       14
       15
        
       	"github.com/go-git/go-git/v5"

     

       16
       16
       +
       	"github.com/go-git/go-git/v5/config"

     

       15
       17
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       16
       18
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       17
       19
        
       )

     

       18
       20
        
       

     

       19
       21
        
       var (

     

       20
       20
       -
       	ErrBinaryFile    = fmt.Errorf("binary file")

     

       21
       21
       -
       	ErrNotBinaryFile = fmt.Errorf("not binary file")

     

       22
       22
       +
       	ErrBinaryFile        = errors.New("binary file")

     

       23
       23
       +
       	ErrNotBinaryFile     = errors.New("not binary file")

     

       24
       24
       +
       	ErrMissingGitModules = errors.New("no .gitmodules file found")

     

       25
       25
       +
       	ErrInvalidGitModules = errors.New("invalid .gitmodules file")

     

       26
       26
       +
       	ErrNotSubmodule      = errors.New("path is not a submodule")

     

       22
       27
        
       )

     

       23
       28
        
       

     

       24
       29
        
       type GitRepo struct {

     
···

       188
       193
        
       	defer reader.Close()

     

       189
       194
        
       

     

       190
       195
        
       	return io.ReadAll(reader)

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       // read and parse .gitmodules

     

       199
       199
       +
       func (g *GitRepo) Submodules() (*config.Modules, error) {

     

       200
       200
       +
       	c, err := g.r.CommitObject(g.h)

     

       201
       201
       +
       	if err != nil {

     

       202
       202
       +
       		return nil, fmt.Errorf("commit object: %w", err)

     

       203
       203
       +
       	}

     

       204
       204
       +
       

     

       205
       205
       +
       	tree, err := c.Tree()

     

       206
       206
       +
       	if err != nil {

     

       207
       207
       +
       		return nil, fmt.Errorf("tree: %w", err)

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	// read .gitmodules file

     

       211
       211
       +
       	modulesEntry, err := tree.FindEntry(".gitmodules")

     

       212
       212
       +
       	if err != nil {

     

       213
       213
       +
       		return nil, fmt.Errorf("%w: %w", ErrMissingGitModules, err)

     

       214
       214
       +
       	}

     

       215
       215
       +
       

     

       216
       216
       +
       	modulesFile, err := tree.TreeEntryFile(modulesEntry)

     

       217
       217
       +
       	if err != nil {

     

       218
       218
       +
       		return nil, fmt.Errorf("%w: failed to read file: %w", ErrInvalidGitModules, err)

     

       219
       219
       +
       	}

     

       220
       220
       +
       

     

       221
       221
       +
       	content, err := modulesFile.Contents()

     

       222
       222
       +
       	if err != nil {

     

       223
       223
       +
       		return nil, fmt.Errorf("%w: failed to read contents: %w", ErrInvalidGitModules, err)

     

       224
       224
       +
       	}

     

       225
       225
       +
       

     

       226
       226
       +
       	// parse .gitmodules

     

       227
       227
       +
       	modules := config.NewModules()

     

       228
       228
       +
       	if err = modules.Unmarshal([]byte(content)); err != nil {

     

       229
       229
       +
       		return nil, fmt.Errorf("%w: failed to parse: %w", ErrInvalidGitModules, err)

     

       230
       230
       +
       	}

     

       231
       231
       +
       

     

       232
       232
       +
       	return modules, nil

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       func (g *GitRepo) Submodule(path string) (*config.Submodule, error) {

     

       236
       236
       +
       	modules, err := g.Submodules()

     

       237
       237
       +
       	if err != nil {

     

       238
       238
       +
       		return nil, err

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	for _, submodule := range modules.Submodules {

     

       242
       242
       +
       		if submodule.Path == path {

     

       243
       243
       +
       			return submodule, nil

     

       244
       244
       +
       		}

     

       245
       245
       +
       	}

     

       246
       246
       +
       

     

       247
       247
       +
       	// path is not a submodule

     

       248
       248
       +
       	return nil, ErrNotSubmodule

     

       191
       249
        
       }

     

       192
       250
        
       

     

       193
       251
        
       func (g *GitRepo) Branch(name string) (*plumbing.Reference, error) {

+4 -13

knotserver/git/tree.go

···

       7
       7
        
       	"path"

     

       8
       8
        
       	"time"

     

       9
       9
        
       

     

       10
       10
       +
       	"github.com/go-git/go-git/v5/plumbing/filemode"

     

       10
       11
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       11
       12
        
       	"tangled.org/core/types"

     

       12
       13
        
       )

     
···

       53
       54
        
       	}

     

       54
       55
        
       

     

       55
       56
        
       	for _, e := range subtree.Entries {

     

       56
       56
       -
       		mode, _ := e.Mode.ToOSFileMode()

     

       57
       57
        
       		sz, _ := subtree.Size(e.Name)

     

       58
       58
       -
       

     

       59
       58
        
       		fpath := path.Join(parent, e.Name)

     

       60
       59
        
       

     

       61
       60
        
       		var lastCommit *types.LastCommitInfo

     
···

       69
       68
        
       

     

       70
       69
        
       		nts = append(nts, types.NiceTree{

     

       71
       70
        
       			Name:       e.Name,

     

       72
       72
       -
       			Mode:       mode.String(),

     

       73
       73
       -
       			IsFile:     e.Mode.IsFile(),

     

       71
       71
       +
       			Mode:       e.Mode.String(),

     

       74
       72
        
       			Size:       sz,

     

       75
       73
        
       			LastCommit: lastCommit,

     

       76
       74
        
       		})

     
···

       126
       124
        
       		default:

     

       127
       125
        
       		}

     

       128
       126
        
       

     

       129
       129
       -
       		mode, err := e.Mode.ToOSFileMode()

     

       130
       130
       -
       		if err != nil {

     

       131
       131
       -
       			// TODO: log this

     

       132
       132
       -
       			continue

     

       133
       133
       -
       		}

     

       134
       134
       -
       

     

       135
       127
        
       		if e.Mode.IsFile() {

     

       136
       136
       -
       			err = cb(e, currentTree, root)

     

       137
       137
       -
       			if errors.Is(err, TerminateWalk) {

     

       128
       128
       +
       			if err := cb(e, currentTree, root); errors.Is(err, TerminateWalk) {

     

       138
       129
        
       				return err

     

       139
       130
        
       			}

     

       140
       131
        
       		}

     

       141
       132
        
       

     

       142
       133
        
       		// e is a directory

     

       143
       143
       -
       		if mode.IsDir() {

     

       134
       134
       +
       		if e.Mode == filemode.Dir {

     

       144
       135
        
       			subtree, err := currentTree.Tree(e.Name)

     

       145
       136
        
       			if err != nil {

     

       146
       137
        
       				return fmt.Errorf("sub tree %s: %w", e.Name, err)

+4 -8

knotserver/ingester.go

···

       16
       16
        
       	"github.com/bluesky-social/jetstream/pkg/models"

     

       17
       17
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       18
       18
        
       	"tangled.org/core/api/tangled"

     

       19
       19
       -
       	"tangled.org/core/idresolver"

     

       20
       19
        
       	"tangled.org/core/knotserver/db"

     

       21
       20
        
       	"tangled.org/core/knotserver/git"

     

       22
       21
        
       	"tangled.org/core/log"

     
···

       120
       119
        
       	}

     

       121
       120
        
       

     

       122
       121
        
       	// resolve this aturi to extract the repo record

     

       123
       123
       -
       	resolver := idresolver.DefaultResolver()

     

       124
       124
       -
       	ident, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       122
       122
       +
       	ident, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       125
       123
        
       	if err != nil || ident.Handle.IsInvalidHandle() {

     

       126
       124
        
       		return fmt.Errorf("failed to resolve handle: %w", err)

     

       127
       125
        
       	}

     
···

       163
       161
        
       

     

       164
       162
        
       	var pipeline workflow.RawPipeline

     

       165
       163
        
       	for _, e := range workflowDir {

     

       166
       166
       -
       		if !e.IsFile {

     

       164
       164
       +
       		if !e.IsFile() {

     

       167
       165
        
       			continue

     

       168
       166
        
       		}

     

       169
       167
        
       

     
···

       233
       231
        
       		return err

     

       234
       232
        
       	}

     

       235
       233
        
       

     

       236
       236
       -
       	resolver := idresolver.DefaultResolver()

     

       237
       237
       -
       

     

       238
       238
       -
       	subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       234
       234
       +
       	subjectId, err := h.resolver.ResolveIdent(ctx, record.Subject)

     

       239
       235
        
       	if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       240
       236
        
       		return err

     

       241
       237
        
       	}

     

       242
       238
        
       

     

       243
       239
        
       	// TODO: fix this for good, we need to fetch the record here unfortunately

     

       244
       240
        
       	// resolve this aturi to extract the repo record

     

       245
       245
       -
       	owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       241
       241
       +
       	owner, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       246
       242
        
       	if err != nil || owner.Handle.IsInvalidHandle() {

     

       247
       243
        
       		return fmt.Errorf("failed to resolve handle: %w", err)

     

       248
       244
        
       	}

+146 -49

knotserver/internal.go

···

       27
       27
        
       )

     

       28
       28
        
       

     

       29
       29
        
       type InternalHandle struct {

     

       30
       30
       -
       	db *db.DB

     

       31
       31
       -
       	c  *config.Config

     

       32
       32
       -
       	e  *rbac.Enforcer

     

       33
       33
       -
       	l  *slog.Logger

     

       34
       34
       -
       	n  *notifier.Notifier

     

       30
       30
       +
       	db  *db.DB

     

       31
       31
       +
       	c   *config.Config

     

       32
       32
       +
       	e   *rbac.Enforcer

     

       33
       33
       +
       	l   *slog.Logger

     

       34
       34
       +
       	n   *notifier.Notifier

     

       35
       35
       +
       	res *idresolver.Resolver

     

       35
       36
        
       }

     

       36
       37
        
       

     

       37
       38
        
       func (h *InternalHandle) PushAllowed(w http.ResponseWriter, r *http.Request) {

     
···

       67
       68
        
       	writeJSON(w, data)

     

       68
       69
        
       }

     

       69
       70
        
       

     

       71
       71
       +
       // response in text/plain format

     

       72
       72
       +
       // the body will be qualified repository path on success/push-denied

     

       73
       73
       +
       // or an error message when process failed

     

       74
       74
       +
       func (h *InternalHandle) Guard(w http.ResponseWriter, r *http.Request) {

     

       75
       75
       +
       	l := h.l.With("handler", "PostReceiveHook")

     

       76
       76
       +
       

     

       77
       77
       +
       	var (

     

       78
       78
       +
       		incomingUser = r.URL.Query().Get("user")

     

       79
       79
       +
       		repo         = r.URL.Query().Get("repo")

     

       80
       80
       +
       		gitCommand   = r.URL.Query().Get("gitCmd")

     

       81
       81
       +
       	)

     

       82
       82
       +
       

     

       83
       83
       +
       	if incomingUser == "" || repo == "" || gitCommand == "" {

     

       84
       84
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       85
       85
       +
       		l.Error("invalid request", "incomingUser", incomingUser, "repo", repo, "gitCommand", gitCommand)

     

       86
       86
       +
       		fmt.Fprintln(w, "invalid internal request")

     

       87
       87
       +
       		return

     

       88
       88
       +
       	}

     

       89
       89
       +
       

     

       90
       90
       +
       	// did:foo/repo-name or

     

       91
       91
       +
       	// handle/repo-name or

     

       92
       92
       +
       	// any of the above with a leading slash (/)

     

       93
       93
       +
       	components := strings.Split(strings.TrimPrefix(strings.Trim(repo, "'"), "/"), "/")

     

       94
       94
       +
       	l.Info("command components", "components", components)

     

       95
       95
       +
       

     

       96
       96
       +
       	if len(components) != 2 {

     

       97
       97
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       98
       98
       +
       		l.Error("invalid repo format", "components", components)

     

       99
       99
       +
       		fmt.Fprintln(w, "invalid repo format, needs <user>/<repo> or /<user>/<repo>")

     

       100
       100
       +
       		return

     

       101
       101
       +
       	}

     

       102
       102
       +
       	repoOwner := components[0]

     

       103
       103
       +
       	repoName := components[1]

     

       104
       104
       +
       

     

       105
       105
       +
       	resolver := idresolver.DefaultResolver(h.c.Server.PlcUrl)

     

       106
       106
       +
       

     

       107
       107
       +
       	repoOwnerIdent, err := resolver.ResolveIdent(r.Context(), repoOwner)

     

       108
       108
       +
       	if err != nil || repoOwnerIdent.Handle.IsInvalidHandle() {

     

       109
       109
       +
       		l.Error("Error resolving handle", "handle", repoOwner, "err", err)

     

       110
       110
       +
       		w.WriteHeader(http.StatusInternalServerError)

     

       111
       111
       +
       		fmt.Fprintf(w, "error resolving handle: invalid handle\n")

     

       112
       112
       +
       		return

     

       113
       113
       +
       	}

     

       114
       114
       +
       	repoOwnerDid := repoOwnerIdent.DID.String()

     

       115
       115
       +
       

     

       116
       116
       +
       	qualifiedRepo, _ := securejoin.SecureJoin(repoOwnerDid, repoName)

     

       117
       117
       +
       

     

       118
       118
       +
       	if gitCommand == "git-receive-pack" {

     

       119
       119
       +
       		ok, err := h.e.IsPushAllowed(incomingUser, rbac.ThisServer, qualifiedRepo)

     

       120
       120
       +
       		if err != nil || !ok {

     

       121
       121
       +
       			w.WriteHeader(http.StatusForbidden)

     

       122
       122
       +
       			fmt.Fprint(w, repo)

     

       123
       123
       +
       			return

     

       124
       124
       +
       		}

     

       125
       125
       +
       	}

     

       126
       126
       +
       

     

       127
       127
       +
       	w.WriteHeader(http.StatusOK)

     

       128
       128
       +
       	fmt.Fprint(w, qualifiedRepo)

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       70
       131
        
       type PushOptions struct {

     

       71
       132
        
       	skipCi    bool

     

       72
       133
        
       	verboseCi bool

     
···

       121
       182
        
       			// non-fatal

     

       122
       183
        
       		}

     

       123
       184
        
       

     

       124
       124
       -
       		if (line.NewSha.String() != line.OldSha.String()) && line.OldSha.IsZero() {

     

       125
       125
       -
       			msg, err := h.replyCompare(line, repoDid, gitRelativeDir, repoName, r.Context())

     

       126
       126
       -
       			if err != nil {

     

       127
       127
       -
       				l.Error("failed to reply with compare link", "err", err, "line", line, "did", gitUserDid, "repo", gitRelativeDir)

     

       128
       128
       -
       				// non-fatal

     

       129
       129
       -
       			} else {

     

       130
       130
       -
       				for msgLine := range msg {

     

       131
       131
       -
       					resp.Messages = append(resp.Messages, msg[msgLine])

     

       132
       132
       -
       				}

     

       133
       133
       -
       			}

     

       185
       185
       +
       		err = h.emitCompareLink(&resp.Messages, line, repoDid, repoName)

     

       186
       186
       +
       		if err != nil {

     

       187
       187
       +
       			l.Error("failed to reply with compare link", "err", err, "line", line, "did", gitUserDid, "repo", gitRelativeDir)

     

       188
       188
       +
       			// non-fatal

     

       134
       189
        
       		}

     

       135
       190
        
       

     

       136
       191
        
       		err = h.triggerPipeline(&resp.Messages, line, gitUserDid, repoDid, repoName, pushOptions)

     
···

       143
       198
        
       	writeJSON(w, resp)

     

       144
       199
        
       }

     

       145
       200
        
       

     

       146
       146
       -
       func (h *InternalHandle) replyCompare(line git.PostReceiveLine, repoOwner string, gitRelativeDir string, repoName string, ctx context.Context) ([]string, error) {

     

       147
       147
       -
       	l := h.l.With("handler", "replyCompare")

     

       148
       148
       -
       	userIdent, err := idresolver.DefaultResolver().ResolveIdent(ctx, repoOwner)

     

       149
       149
       -
       	user := repoOwner

     

       150
       150
       -
       	if err != nil {

     

       151
       151
       -
       		l.Error("Failed to fetch user identity", "err", err)

     

       152
       152
       -
       		// non-fatal

     

       153
       153
       -
       	} else {

     

       154
       154
       -
       		user = userIdent.Handle.String()

     

       155
       155
       -
       	}

     

       156
       156
       -
       	gr, err := git.PlainOpen(gitRelativeDir)

     

       157
       157
       -
       	if err != nil {

     

       158
       158
       -
       		l.Error("Failed to open git repository", "err", err)

     

       159
       159
       -
       		return []string{}, err

     

       160
       160
       -
       	}

     

       161
       161
       -
       	defaultBranch, err := gr.FindMainBranch()

     

       162
       162
       -
       	if err != nil {

     

       163
       163
       -
       		l.Error("Failed to fetch default branch", "err", err)

     

       164
       164
       -
       		return []string{}, err

     

       165
       165
       -
       	}

     

       166
       166
       -
       	if line.Ref == plumbing.NewBranchReferenceName(defaultBranch).String() {

     

       167
       167
       -
       		return []string{}, nil

     

       168
       168
       -
       	}

     

       169
       169
       -
       	ZWS := "\u200B"

     

       170
       170
       -
       	var msg []string

     

       171
       171
       -
       	msg = append(msg, ZWS)

     

       172
       172
       -
       	msg = append(msg, fmt.Sprintf("Create a PR pointing to %s", defaultBranch))

     

       173
       173
       -
       	msg = append(msg, fmt.Sprintf("\t%s/%s/%s/compare/%s...%s", h.c.AppViewEndpoint, user, repoName, defaultBranch, strings.TrimPrefix(line.Ref, "refs/heads/")))

     

       174
       174
       -
       	msg = append(msg, ZWS)

     

       175
       175
       -
       	return msg, nil

     

       176
       176
       -
       }

     

       177
       177
       -
       

     

       178
       201
        
       func (h *InternalHandle) insertRefUpdate(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error {

     

       179
       202
        
       	didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName)

     

       180
       203
        
       	if err != nil {

     
···

       220
       243
        
       	return errors.Join(errs, h.db.InsertEvent(event, h.n))

     

       221
       244
        
       }

     

       222
       245
        
       

     

       223
       223
       -
       func (h *InternalHandle) triggerPipeline(clientMsgs *[]string, line git.PostReceiveLine, gitUserDid, repoDid, repoName string, pushOptions PushOptions) error {

     

       246
       246
       +
       func (h *InternalHandle) triggerPipeline(

     

       247
       247
       +
       	clientMsgs *[]string,

     

       248
       248
       +
       	line git.PostReceiveLine,

     

       249
       249
       +
       	gitUserDid string,

     

       250
       250
       +
       	repoDid string,

     

       251
       251
       +
       	repoName string,

     

       252
       252
       +
       	pushOptions PushOptions,

     

       253
       253
       +
       ) error {

     

       224
       254
        
       	if pushOptions.skipCi {

     

       225
       255
        
       		return nil

     

       226
       256
        
       	}

     
···

       247
       277
        
       

     

       248
       278
        
       	var pipeline workflow.RawPipeline

     

       249
       279
        
       	for _, e := range workflowDir {

     

       250
       250
       -
       		if !e.IsFile {

     

       280
       280
       +
       		if !e.IsFile() {

     

       251
       281
        
       			continue

     

       252
       282
        
       		}

     

       253
       283
        
       

     
···

       315
       345
        
       	return h.db.InsertEvent(event, h.n)

     

       316
       346
        
       }

     

       317
       347
        
       

     

       348
       348
       +
       func (h *InternalHandle) emitCompareLink(

     

       349
       349
       +
       	clientMsgs *[]string,

     

       350
       350
       +
       	line git.PostReceiveLine,

     

       351
       351
       +
       	repoDid string,

     

       352
       352
       +
       	repoName string,

     

       353
       353
       +
       ) error {

     

       354
       354
       +
       	// this is a second push to a branch, don't reply with the link again

     

       355
       355
       +
       	if !line.OldSha.IsZero() {

     

       356
       356
       +
       		return nil

     

       357
       357
       +
       	}

     

       358
       358
       +
       

     

       359
       359
       +
       	// the ref was not updated to a new hash, don't reply with the link

     

       360
       360
       +
       	//

     

       361
       361
       +
       	// NOTE: do we need this?

     

       362
       362
       +
       	if line.NewSha.String() == line.OldSha.String() {

     

       363
       363
       +
       		return nil

     

       364
       364
       +
       	}

     

       365
       365
       +
       

     

       366
       366
       +
       	pushedRef := plumbing.ReferenceName(line.Ref)

     

       367
       367
       +
       

     

       368
       368
       +
       	userIdent, err := h.res.ResolveIdent(context.Background(), repoDid)

     

       369
       369
       +
       	user := repoDid

     

       370
       370
       +
       	if err == nil {

     

       371
       371
       +
       		user = userIdent.Handle.String()

     

       372
       372
       +
       	}

     

       373
       373
       +
       

     

       374
       374
       +
       	didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName)

     

       375
       375
       +
       	if err != nil {

     

       376
       376
       +
       		return err

     

       377
       377
       +
       	}

     

       378
       378
       +
       

     

       379
       379
       +
       	repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, didSlashRepo)

     

       380
       380
       +
       	if err != nil {

     

       381
       381
       +
       		return err

     

       382
       382
       +
       	}

     

       383
       383
       +
       

     

       384
       384
       +
       	gr, err := git.PlainOpen(repoPath)

     

       385
       385
       +
       	if err != nil {

     

       386
       386
       +
       		return err

     

       387
       387
       +
       	}

     

       388
       388
       +
       

     

       389
       389
       +
       	defaultBranch, err := gr.FindMainBranch()

     

       390
       390
       +
       	if err != nil {

     

       391
       391
       +
       		return err

     

       392
       392
       +
       	}

     

       393
       393
       +
       

     

       394
       394
       +
       	// pushing to default branch

     

       395
       395
       +
       	if pushedRef == plumbing.NewBranchReferenceName(defaultBranch) {

     

       396
       396
       +
       		return nil

     

       397
       397
       +
       	}

     

       398
       398
       +
       

     

       399
       399
       +
       	// pushing a tag, don't prompt the user the open a PR

     

       400
       400
       +
       	if pushedRef.IsTag() {

     

       401
       401
       +
       		return nil

     

       402
       402
       +
       	}

     

       403
       403
       +
       

     

       404
       404
       +
       	ZWS := "\u200B"

     

       405
       405
       +
       	*clientMsgs = append(*clientMsgs, ZWS)

     

       406
       406
       +
       	*clientMsgs = append(*clientMsgs, fmt.Sprintf("Create a PR pointing to %s", defaultBranch))

     

       407
       407
       +
       	*clientMsgs = append(*clientMsgs, fmt.Sprintf("\t%s/%s/%s/compare/%s...%s", h.c.AppViewEndpoint, user, repoName, defaultBranch, strings.TrimPrefix(line.Ref, "refs/heads/")))

     

       408
       408
       +
       	*clientMsgs = append(*clientMsgs, ZWS)

     

       409
       409
       +
       	return nil

     

       410
       410
       +
       }

     

       411
       411
       +
       

     

       318
       412
        
       func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, n *notifier.Notifier) http.Handler {

     

       319
       413
        
       	r := chi.NewRouter()

     

       320
       414
        
       	l := log.FromContext(ctx)

     

       321
       415
        
       	l = log.SubLogger(l, "internal")

     

       416
       416
       +
       	res := idresolver.DefaultResolver(c.Server.PlcUrl)

     

       322
       417
        
       

     

       323
       418
        
       	h := InternalHandle{

     

       324
       419
        
       		db,

     
···

       326
       421
        
       		e,

     

       327
       422
        
       		l,

     

       328
       423
        
       		n,

     

       424
       424
       +
       		res,

     

       329
       425
        
       	}

     

       330
       426
        
       

     

       331
       427
        
       	r.Get("/push-allowed", h.PushAllowed)

     

       332
       428
        
       	r.Get("/keys", h.InternalKeys)

     

       429
       429
       +
       	r.Get("/guard", h.Guard)

     

       333
       430
        
       	r.Post("/hooks/post-receive", h.PostReceiveHook)

     

       334
       431
        
       	r.Mount("/debug", middleware.Profiler())

     

       335
       432

+18

knotserver/middleware.go

···

       33
       33
        
       		)

     

       34
       34
        
       	})

     

       35
       35
        
       }

     

       36
       36
       +
       

     

       37
       37
       +
       func (h *Knot) CORS(next http.Handler) http.Handler {

     

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

     

       39
       39
       +
       		// Set CORS headers

     

       40
       40
       +
       		w.Header().Set("Access-Control-Allow-Origin", "*")

     

       41
       41
       +
       		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")

     

       42
       42
       +
       		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

     

       43
       43
       +
       		w.Header().Set("Access-Control-Max-Age", "86400")

     

       44
       44
       +
       

     

       45
       45
       +
       		// Handle preflight requests

     

       46
       46
       +
       		if r.Method == "OPTIONS" {

     

       47
       47
       +
       			w.WriteHeader(http.StatusOK)

     

       48
       48
       +
       			return

     

       49
       49
       +
       		}

     

       50
       50
       +
       

     

       51
       51
       +
       		next.ServeHTTP(w, r)

     

       52
       52
       +
       	})

     

       53
       53
       +
       }

+2 -1

knotserver/router.go

···

       36
       36
        
       		l:        log.FromContext(ctx),

     

       37
       37
        
       		jc:       jc,

     

       38
       38
        
       		n:        n,

     

       39
       39
       -
       		resolver: idresolver.DefaultResolver(),

     

       39
       39
       +
       		resolver: idresolver.DefaultResolver(c.Server.PlcUrl),

     

       40
       40
        
       	}

     

       41
       41
        
       

     

       42
       42
        
       	err := e.AddKnot(rbac.ThisServer)

     
···

       71
       71
        
       func (h *Knot) Router() http.Handler {

     

       72
       72
        
       	r := chi.NewRouter()

     

       73
       73
        
       

     

       74
       74
       +
       	r.Use(h.CORS)

     

       74
       75
        
       	r.Use(h.RequestLogger)

     

       75
       76
        
       

     

       76
       77
        
       	r.Get("/", func(w http.ResponseWriter, r *http.Request) {

+1 -1

knotserver/server.go

···

       64
       64
        
       		logger.Info("running in dev mode, signature verification is disabled")

     

       65
       65
        
       	}

     

       66
       66
        
       

     

       67
       67
       -
       	db, err := db.Setup(c.Server.DBPath)

     

       67
       67
       +
       	db, err := db.Setup(ctx, c.Server.DBPath)

     

       68
       68
        
       	if err != nil {

     

       69
       69
        
       		return fmt.Errorf("failed to load db: %w", err)

     

       70
       70
        
       	}

+1 -1

knotserver/xrpc/create_repo.go

···

       84
       84
        
       	repoPath, _ := securejoin.SecureJoin(h.Config.Repo.ScanPath, relativeRepoPath)

     

       85
       85
        
       

     

       86
       86
        
       	if data.Source != nil && *data.Source != "" {

     

       87
       87
       -
       		err = git.Fork(repoPath, *data.Source)

     

       87
       87
       +
       		err = git.Fork(repoPath, *data.Source, h.Config)

     

       88
       88
        
       		if err != nil {

     

       89
       89
        
       			l.Error("forking repo", "error", err.Error())

     

       90
       90
        
       			writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError)

+21 -2

knotserver/xrpc/repo_blob.go

···

       42
       42
        
       		return

     

       43
       43
        
       	}

     

       44
       44
        
       

     

       45
       45
       +
       	// first check if this path is a submodule

     

       46
       46
       +
       	submodule, err := gr.Submodule(treePath)

     

       47
       47
       +
       	if err != nil {

     

       48
       48
       +
       		// this is okay, continue and try to treat it as a regular file

     

       49
       49
       +
       	} else {

     

       50
       50
       +
       		response := tangled.RepoBlob_Output{

     

       51
       51
       +
       			Ref:  ref,

     

       52
       52
       +
       			Path: treePath,

     

       53
       53
       +
       			Submodule: &tangled.RepoBlob_Submodule{

     

       54
       54
       +
       				Name:   submodule.Name,

     

       55
       55
       +
       				Url:    submodule.URL,

     

       56
       56
       +
       				Branch: &submodule.Branch,

     

       57
       57
       +
       			},

     

       58
       58
       +
       		}

     

       59
       59
       +
       		writeJson(w, response)

     

       60
       60
       +
       		return

     

       61
       61
       +
       	}

     

       62
       62
       +
       

     

       45
       63
        
       	contents, err := gr.RawContent(treePath)

     

       46
       64
        
       	if err != nil {

     

       47
       65
        
       		x.Logger.Error("file content", "error", err.Error(), "treePath", treePath)

     
···

       101
       119
        
       	var encoding string

     

       102
       120
        
       

     

       103
       121
        
       	isBinary := !isTextual(mimeType)

     

       122
       122
       +
       	size := int64(len(contents))

     

       104
       123
        
       

     

       105
       124
        
       	if isBinary {

     

       106
       125
        
       		content = base64.StdEncoding.EncodeToString(contents)

     
···

       113
       132
        
       	response := tangled.RepoBlob_Output{

     

       114
       133
        
       		Ref:      ref,

     

       115
       134
        
       		Path:     treePath,

     

       116
       116
       -
       		Content:  content,

     

       135
       135
       +
       		Content:  &content,

     

       117
       136
        
       		Encoding: &encoding,

     

       118
       118
       -
       		Size:     &[]int64{int64(len(contents))}[0],

     

       137
       137
       +
       		Size:     &size,

     

       119
       138
        
       		IsBinary: &isBinary,

     

       120
       139
        
       	}

     

       121
       140

+6 -1

knotserver/xrpc/repo_log.go

···

       62
       62
        
       		return

     

       63
       63
        
       	}

     

       64
       64
        
       

     

       65
       65
       +
       	tcommits := make([]types.Commit, len(commits))

     

       66
       66
       +
       	for i, c := range commits {

     

       67
       67
       +
       		tcommits[i].FromGoGitCommit(c)

     

       68
       68
       +
       	}

     

       69
       69
       +
       

     

       65
       70
        
       	// Create response using existing types.RepoLogResponse

     

       66
       71
        
       	response := types.RepoLogResponse{

     

       67
       67
       -
       		Commits: commits,

     

       72
       72
       +
       		Commits: tcommits,

     

       68
       73
        
       		Ref:     ref,

     

       69
       74
        
       		Page:    (offset / limit) + 1,

     

       70
       75
        
       		PerPage: limit,

+3 -5

knotserver/xrpc/repo_tree.go

···

       67
       67
        
       	treeEntries := make([]*tangled.RepoTree_TreeEntry, len(files))

     

       68
       68
        
       	for i, file := range files {

     

       69
       69
        
       		entry := &tangled.RepoTree_TreeEntry{

     

       70
       70
       -
       			Name:       file.Name,

     

       71
       71
       -
       			Mode:       file.Mode,

     

       72
       72
       -
       			Size:       file.Size,

     

       73
       73
       -
       			Is_file:    file.IsFile,

     

       74
       74
       -
       			Is_subtree: file.IsSubtree,

     

       70
       70
       +
       			Name: file.Name,

     

       71
       71
       +
       			Mode: file.Mode,

     

       72
       72
       +
       			Size: file.Size,

     

       75
       73
        
       		}

     

       76
       74
        
       

     

       77
       75
        
       		if file.LastCommit != nil {

lexicons/actor/profile.json

···

       64
       64
        
                     "type": "string",

     

       65
       65
        
                     "format": "at-uri"

     

       66
       66
        
                   }

     

       67
       67
       +
                 },

     

       68
       68
       +
                 "pronouns": {

     

       69
       69
       +
                   "type": "string",

     

       70
       70
       +
                   "description": "Preferred gender pronouns.",

     

       71
       71
       +
                   "maxLength": 40

     

       67
       72
        
                 }

     

       68
       73
        
               }

     

       69
       74
        
             }

+14

lexicons/issue/comment.json

···

       29
       29
        
                 "replyTo": {

     

       30
       30
        
                   "type": "string",

     

       31
       31
        
                   "format": "at-uri"

     

       32
       32
       +
                 },

     

       33
       33
       +
                 "mentions": {

     

       34
       34
       +
                   "type": "array",

     

       35
       35
       +
                   "items": {

     

       36
       36
       +
                     "type": "string",

     

       37
       37
       +
                     "format": "did"

     

       38
       38
       +
                   }

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "references": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "items": {

     

       43
       43
       +
                     "type": "string",

     

       44
       44
       +
                     "format": "at-uri"

     

       45
       45
       +
                   }

     

       32
       46
        
                 }

     

       33
       47
        
               }

     

       34
       48
        
             }

+14

lexicons/issue/issue.json

···

       24
       24
        
                 "createdAt": {

     

       25
       25
        
                   "type": "string",

     

       26
       26
        
                   "format": "datetime"

     

       27
       27
       +
                 },

     

       28
       28
       +
                 "mentions": {

     

       29
       29
       +
                   "type": "array",

     

       30
       30
       +
                   "items": {

     

       31
       31
       +
                     "type": "string",

     

       32
       32
       +
                     "format": "did"

     

       33
       33
       +
                   }

     

       34
       34
       +
                 },

     

       35
       35
       +
                 "references": {

     

       36
       36
       +
                   "type": "array",

     

       37
       37
       +
                   "items": {

     

       38
       38
       +
                     "type": "string",

     

       39
       39
       +
                     "format": "at-uri"

     

       40
       40
       +
                   }

     

       27
       41
        
                 }

     

       28
       42
        
               }

     

       29
       43
        
             }

+14

lexicons/pulls/comment.json

···

       25
       25
        
                 "createdAt": {

     

       26
       26
        
                   "type": "string",

     

       27
       27
        
                   "format": "datetime"

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "mentions": {

     

       30
       30
       +
                   "type": "array",

     

       31
       31
       +
                   "items": {

     

       32
       32
       +
                     "type": "string",

     

       33
       33
       +
                     "format": "did"

     

       34
       34
       +
                   }

     

       35
       35
       +
                 },

     

       36
       36
       +
                 "references": {

     

       37
       37
       +
                   "type": "array",

     

       38
       38
       +
                   "items": {

     

       39
       39
       +
                     "type": "string",

     

       40
       40
       +
                     "format": "at-uri"

     

       41
       41
       +
                   }

     

       28
       42
        
                 }

     

       29
       43
        
               }

     

       30
       44
        
             }

+14

lexicons/pulls/pull.json

···

       36
       36
        
                 "createdAt": {

     

       37
       37
        
                   "type": "string",

     

       38
       38
        
                   "format": "datetime"

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "mentions": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "items": {

     

       43
       43
       +
                     "type": "string",

     

       44
       44
       +
                     "format": "did"

     

       45
       45
       +
                   }

     

       46
       46
       +
                 },

     

       47
       47
       +
                 "references": {

     

       48
       48
       +
                   "type": "array",

     

       49
       49
       +
                   "items": {

     

       50
       50
       +
                     "type": "string",

     

       51
       51
       +
                     "format": "at-uri"

     

       52
       52
       +
                   }

     

       39
       53
        
                 }

     

       40
       54
        
               }

     

       41
       55
        
             }

+49 -5

lexicons/repo/blob.json

···

       6
       6
        
             "type": "query",

     

       7
       7
        
             "parameters": {

     

       8
       8
        
               "type": "params",

     

       9
       9
       -
               "required": ["repo", "ref", "path"],

     

       9
       9
       +
               "required": [

     

       10
       10
       +
                 "repo",

     

       11
       11
       +
                 "ref",

     

       12
       12
       +
                 "path"

     

       13
       13
       +
               ],

     

       10
       14
        
               "properties": {

     

       11
       15
        
                 "repo": {

     

       12
       16
        
                   "type": "string",

     
···

       31
       35
        
               "encoding": "application/json",

     

       32
       36
        
               "schema": {

     

       33
       37
        
                 "type": "object",

     

       34
       34
       -
                 "required": ["ref", "path", "content"],

     

       38
       38
       +
                 "required": [

     

       39
       39
       +
                   "ref",

     

       40
       40
       +
                   "path"

     

       41
       41
       +
                 ],

     

       35
       42
        
                 "properties": {

     

       36
       43
        
                   "ref": {

     

       37
       44
        
                     "type": "string",

     
···

       48
       55
        
                   "encoding": {

     

       49
       56
        
                     "type": "string",

     

       50
       57
        
                     "description": "Content encoding",

     

       51
       51
       -
                     "enum": ["utf-8", "base64"]

     

       58
       58
       +
                     "enum": [

     

       59
       59
       +
                       "utf-8",

     

       60
       60
       +
                       "base64"

     

       61
       61
       +
                     ]

     

       52
       62
        
                   },

     

       53
       63
        
                   "size": {

     

       54
       64
        
                     "type": "integer",

     
···

       61
       71
        
                   "mimeType": {

     

       62
       72
        
                     "type": "string",

     

       63
       73
        
                     "description": "MIME type of the file"

     

       74
       74
       +
                   },

     

       75
       75
       +
                   "submodule": {

     

       76
       76
       +
                     "type": "ref",

     

       77
       77
       +
                     "ref": "#submodule",

     

       78
       78
       +
                     "description": "Submodule information if path is a submodule"

     

       64
       79
        
                   },

     

       65
       80
        
                   "lastCommit": {

     

       66
       81
        
                     "type": "ref",

     
···

       90
       105
        
           },

     

       91
       106
        
           "lastCommit": {

     

       92
       107
        
             "type": "object",

     

       93
       93
       -
             "required": ["hash", "message", "when"],

     

       108
       108
       +
             "required": [

     

       109
       109
       +
               "hash",

     

       110
       110
       +
               "message",

     

       111
       111
       +
               "when"

     

       112
       112
       +
             ],

     

       94
       113
        
             "properties": {

     

       95
       114
        
               "hash": {

     

       96
       115
        
                 "type": "string",

     
···

       117
       136
        
           },

     

       118
       137
        
           "signature": {

     

       119
       138
        
             "type": "object",

     

       120
       120
       -
             "required": ["name", "email", "when"],

     

       139
       139
       +
             "required": [

     

       140
       140
       +
               "name",

     

       141
       141
       +
               "email",

     

       142
       142
       +
               "when"

     

       143
       143
       +
             ],

     

       121
       144
        
             "properties": {

     

       122
       145
        
               "name": {

     

       123
       146
        
                 "type": "string",

     
···

       131
       154
        
                 "type": "string",

     

       132
       155
        
                 "format": "datetime",

     

       133
       156
        
                 "description": "Author timestamp"

     

       157
       157
       +
               }

     

       158
       158
       +
             }

     

       159
       159
       +
           },

     

       160
       160
       +
           "submodule": {

     

       161
       161
       +
             "type": "object",

     

       162
       162
       +
             "required": [

     

       163
       163
       +
               "name",

     

       164
       164
       +
               "url"

     

       165
       165
       +
             ],

     

       166
       166
       +
             "properties": {

     

       167
       167
       +
               "name": {

     

       168
       168
       +
                 "type": "string",

     

       169
       169
       +
                 "description": "Submodule name"

     

       170
       170
       +
               },

     

       171
       171
       +
               "url": {

     

       172
       172
       +
                 "type": "string",

     

       173
       173
       +
                 "description": "Submodule repository URL"

     

       174
       174
       +
               },

     

       175
       175
       +
               "branch": {

     

       176
       176
       +
                 "type": "string",

     

       177
       177
       +
                 "description": "Branch to track in the submodule"

     

       134
       178
        
               }

     

       135
       179
        
             }

     

       136
       180
        
           }

+15

lexicons/repo/repo.json

···

       32
       32
        
                   "minGraphemes": 1,

     

       33
       33
        
                   "maxGraphemes": 140

     

       34
       34
        
                 },

     

       35
       35
       +
                 "website": {

     

       36
       36
       +
                   "type": "string",

     

       37
       37
       +
                   "format": "uri",

     

       38
       38
       +
                   "description": "Any URI related to the repo"

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "topics": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "description": "Topics related to the repo",

     

       43
       43
       +
                   "items": {

     

       44
       44
       +
                     "type": "string",

     

       45
       45
       +
                     "minLength": 1,

     

       46
       46
       +
                     "maxLength": 50

     

       47
       47
       +
                   },

     

       48
       48
       +
                   "maxLength": 50

     

       49
       49
       +
                 },

     

       35
       50
        
                 "source": {

     

       36
       51
        
                   "type": "string",

     

       37
       52
        
                   "format": "uri",

+1 -9

lexicons/repo/tree.json

···

       91
       91
        
           },

     

       92
       92
        
           "treeEntry": {

     

       93
       93
        
             "type": "object",

     

       94
       94
       -
             "required": ["name", "mode", "size", "is_file", "is_subtree"],

     

       94
       94
       +
             "required": ["name", "mode", "size"],

     

       95
       95
        
             "properties": {

     

       96
       96
        
               "name": {

     

       97
       97
        
                 "type": "string",

     
···

       104
       104
        
               "size": {

     

       105
       105
        
                 "type": "integer",

     

       106
       106
        
                 "description": "File size in bytes"

     

       107
       107
       -
               },

     

       108
       108
       -
               "is_file": {

     

       109
       109
       -
                 "type": "boolean",

     

       110
       110
       -
                 "description": "Whether this entry is a file"

     

       111
       111
       -
               },

     

       112
       112
       -
               "is_subtree": {

     

       113
       113
       -
                 "type": "boolean",

     

       114
       114
       -
                 "description": "Whether this entry is a directory/subtree"

     

       115
       107
        
               },

     

       116
       108
        
               "last_commit": {

     

       117
       109
        
                 "type": "ref",

+83 -32

nix/gomod2nix.toml

···

       13
       13
        
         [mod."github.com/ProtonMail/go-crypto"]

     

       14
       14
        
           version = "v1.3.0"

     

       15
       15
        
           hash = "sha256-TUG+C4MyeWglOmiwiW2/NUVurFHXLgEPRd3X9uQ1NGI="

     

       16
       16
       +
         [mod."github.com/RoaringBitmap/roaring/v2"]

     

       17
       17
       +
           version = "v2.4.5"

     

       18
       18
       +
           hash = "sha256-igWY0S1PTolQkfctYcmVJioJyV1pk2V81X6o6BA1XQA="

     

       16
       19
        
         [mod."github.com/alecthomas/assert/v2"]

     

       17
       20
        
           version = "v2.11.0"

     

       18
       21
        
           hash = "sha256-tDJCDKZ0R4qNA7hgMKWrpDyogt1802LCJDBCExxdqaU="

     
···

       38
       41
        
         [mod."github.com/beorn7/perks"]

     

       39
       42
        
           version = "v1.0.1"

     

       40
       43
        
           hash = "sha256-h75GUqfwJKngCJQVE5Ao5wnO3cfKD9lSIteoLp/3xJ4="

     

       44
       44
       +
         [mod."github.com/bits-and-blooms/bitset"]

     

       45
       45
       +
           version = "v1.22.0"

     

       46
       46
       +
           hash = "sha256-lY1K29h4vlAmJVvwKgbTG8BTACYGjFaginCszN+ST6w="

     

       47
       47
       +
         [mod."github.com/blevesearch/bleve/v2"]

     

       48
       48
       +
           version = "v2.5.3"

     

       49
       49
       +
           hash = "sha256-DkpX43WMpB8+9KCibdNjyf6N/1a51xJTfGF97xdoCAQ="

     

       50
       50
       +
         [mod."github.com/blevesearch/bleve_index_api"]

     

       51
       51
       +
           version = "v1.2.8"

     

       52
       52
       +
           hash = "sha256-LyGDBRvK2GThgUFLZoAbDOOKP1M9Z8oy0E2M6bHZdrk="

     

       53
       53
       +
         [mod."github.com/blevesearch/geo"]

     

       54
       54
       +
           version = "v0.2.4"

     

       55
       55
       +
           hash = "sha256-W1OV/pvqzJC28VJomGnIU/HeBZ689+p54vWdZ1z/bxc="

     

       56
       56
       +
         [mod."github.com/blevesearch/go-faiss"]

     

       57
       57
       +
           version = "v1.0.25"

     

       58
       58
       +
           hash = "sha256-bcm976UX22aNIuSjBxFaYMKTltO9lbqyeG4Z3KVG3/Y="

     

       59
       59
       +
         [mod."github.com/blevesearch/go-porterstemmer"]

     

       60
       60
       +
           version = "v1.0.3"

     

       61
       61
       +
           hash = "sha256-hUjo6g1ehUD1awBmta0ji/xoooD2qG7O22HIeSQiRFo="

     

       62
       62
       +
         [mod."github.com/blevesearch/gtreap"]

     

       63
       63
       +
           version = "v0.1.1"

     

       64
       64
       +
           hash = "sha256-B4p/5RnECRfV4yOiSQDLMHb23uI7lsQDePhNK+zjbF4="

     

       65
       65
       +
         [mod."github.com/blevesearch/mmap-go"]

     

       66
       66
       +
           version = "v1.0.4"

     

       67
       67
       +
           hash = "sha256-8y0nMAE9goKjYhR/FFEvtbP7cvM46xneE461L1Jn2Pg="

     

       68
       68
       +
         [mod."github.com/blevesearch/scorch_segment_api/v2"]

     

       69
       69
       +
           version = "v2.3.10"

     

       70
       70
       +
           hash = "sha256-BcBRjVOrsYySdsdgEjS3qHFm/c58KUNJepRPUO0lFmY="

     

       71
       71
       +
         [mod."github.com/blevesearch/segment"]

     

       72
       72
       +
           version = "v0.9.1"

     

       73
       73
       +
           hash = "sha256-0EAT737kNxl8IJFGl2SD9mOzxolONGgpfaYEGr7JXkQ="

     

       74
       74
       +
         [mod."github.com/blevesearch/snowballstem"]

     

       75
       75
       +
           version = "v0.9.0"

     

       76
       76
       +
           hash = "sha256-NQsXrhXcYXn4jQcvwjwLc96SGMRcqVlrR6hYKWGk7/s="

     

       77
       77
       +
         [mod."github.com/blevesearch/upsidedown_store_api"]

     

       78
       78
       +
           version = "v1.0.2"

     

       79
       79
       +
           hash = "sha256-P69Mnh6YR5RI73bD6L7BYDxkVmaqPMNUrjbfSJoKWuo="

     

       80
       80
       +
         [mod."github.com/blevesearch/vellum"]

     

       81
       81
       +
           version = "v1.1.0"

     

       82
       82
       +
           hash = "sha256-GJ1wslEJEZhPbMiANw0W4Dgb1ZouiILbWEaIUfxZTkw="

     

       83
       83
       +
         [mod."github.com/blevesearch/zapx/v11"]

     

       84
       84
       +
           version = "v11.4.2"

     

       85
       85
       +
           hash = "sha256-YzRcc2GwV4VL2Bc+tXOOUL6xNi8LWS76DXEcTkFPTaQ="

     

       86
       86
       +
         [mod."github.com/blevesearch/zapx/v12"]

     

       87
       87
       +
           version = "v12.4.2"

     

       88
       88
       +
           hash = "sha256-yqyzkMWpyXZSF9KLjtiuOmnRUfhaZImk27mU8lsMyJY="

     

       89
       89
       +
         [mod."github.com/blevesearch/zapx/v13"]

     

       90
       90
       +
           version = "v13.4.2"

     

       91
       91
       +
           hash = "sha256-VSS2fI7YUkeGMBH89TB9yW5qG8MWjM6zKbl8DboHsB4="

     

       92
       92
       +
         [mod."github.com/blevesearch/zapx/v14"]

     

       93
       93
       +
           version = "v14.4.2"

     

       94
       94
       +
           hash = "sha256-mAWr+vK0uZWMUaJfGfchzQo4dzMdBbD3Z7F84Jn/ktg="

     

       95
       95
       +
         [mod."github.com/blevesearch/zapx/v15"]

     

       96
       96
       +
           version = "v15.4.2"

     

       97
       97
       +
           hash = "sha256-R8Eh3N4e8CDXiW47J8ZBnfMY1TTnX1SJPwQc4gYChi8="

     

       98
       98
       +
         [mod."github.com/blevesearch/zapx/v16"]

     

       99
       99
       +
           version = "v16.2.4"

     

       100
       100
       +
           hash = "sha256-Jo5k7DflV/ghszOWJTCOGVyyLMvlvSYyxRrmSIFjyEE="

     

       41
       101
        
         [mod."github.com/bluekeyes/go-gitdiff"]

     

       42
       102
        
           version = "v0.8.2"

     

       43
       103
        
           hash = "sha256-GWm5i1ukuBukV0GMF1rffpbOSSXZdfg6/0pABMiGzLQ="

     
···

       49
       109
        
           version = "v0.0.0-20241210005130-ea96859b93d1"

     

       50
       110
        
           hash = "sha256-AiapbrkjXboIKc5QNiWH0KyNs0zKnn6UlGwWFlkUfm0="

     

       51
       111
        
         [mod."github.com/bmatcuk/doublestar/v4"]

     

       52
       52
       -
           version = "v4.7.1"

     

       53
       53
       -
           hash = "sha256-idO38nWZtmxvE0CgdziepwFM+Xc70Isr6NiKEZjHOjA="

     

       112
       112
       +
           version = "v4.9.1"

     

       113
       113
       +
           hash = "sha256-0iyHjyTAsfhgYSsE+NKxSNGBuM3Id615VWeQhssTShE="

     

       54
       114
        
         [mod."github.com/carlmjohnson/versioninfo"]

     

       55
       115
        
           version = "v0.22.5"

     

       56
       116
        
           hash = "sha256-tf7yKVFTUPmGKBLK43bjyIRQUboCYduh3I5HXE5+LPw="

     
···

       105
       165
        
         [mod."github.com/davecgh/go-spew"]

     

       106
       166
        
           version = "v1.1.2-0.20180830191138-d8f796af33cc"

     

       107
       167
        
           hash = "sha256-fV9oI51xjHdOmEx6+dlq7Ku2Ag+m/bmbzPo6A4Y74qc="

     

       108
       108
       -
         [mod."github.com/decred/dcrd/dcrec/secp256k1/v4"]

     

       109
       109
       -
           version = "v4.4.0"

     

       110
       110
       -
           hash = "sha256-qrhEIwhDll3cxoVpMbm1NQ9/HTI42S7ms8Buzlo5HCg="

     

       111
       168
        
         [mod."github.com/dgraph-io/ristretto"]

     

       112
       169
        
           version = "v0.2.0"

     

       113
       170
        
           hash = "sha256-bnpxX+oO/Qf7IJevA0gsbloVoqRx+5bh7RQ9d9eLNYw="

     
···

       199
       256
        
         [mod."github.com/golang/mock"]

     

       200
       257
        
           version = "v1.6.0"

     

       201
       258
        
           hash = "sha256-fWdnMQisRbiRzGT3ISrUHovquzLRHWvcv1JEsJFZRno="

     

       259
       259
       +
         [mod."github.com/golang/protobuf"]

     

       260
       260
       +
           version = "v1.5.4"

     

       261
       261
       +
           hash = "sha256-N3+Lv9lEZjrdOWdQhFj6Y3Iap4rVLEQeI8/eFFyAMZ0="

     

       262
       262
       +
         [mod."github.com/golang/snappy"]

     

       263
       263
       +
           version = "v0.0.4"

     

       264
       264
       +
           hash = "sha256-Umx+5xHAQCN/Gi4HbtMhnDCSPFAXSsjVbXd8n5LhjAA="

     

       202
       265
        
         [mod."github.com/google/go-querystring"]

     

       203
       266
        
           version = "v1.1.0"

     

       204
       267
        
           hash = "sha256-itsKgKghuX26czU79cK6C2n+lc27jm5Dw1XbIRgwZJY="

     
···

       295
       358
        
         [mod."github.com/ipfs/go-metrics-interface"]

     

       296
       359
        
           version = "v0.3.0"

     

       297
       360
        
           hash = "sha256-b3tp3jxecLmJEGx2kW7MiKGlAKPEWg/LJ7hXylSC8jQ="

     

       361
       361
       +
         [mod."github.com/json-iterator/go"]

     

       362
       362
       +
           version = "v1.1.12"

     

       363
       363
       +
           hash = "sha256-To8A0h+lbfZ/6zM+2PpRpY3+L6725OPC66lffq6fUoM="

     

       298
       364
        
         [mod."github.com/kevinburke/ssh_config"]

     

       299
       365
        
           version = "v1.2.0"

     

       300
       366
        
           hash = "sha256-Ta7ZOmyX8gG5tzWbY2oES70EJPfI90U7CIJS9EAce0s="

     
···

       304
       370
        
         [mod."github.com/klauspost/cpuid/v2"]

     

       305
       371
        
           version = "v2.3.0"

     

       306
       372
        
           hash = "sha256-50JhbQyT67BK38HIdJihPtjV7orYp96HknI2VP7A9Yc="

     

       307
       307
       -
         [mod."github.com/lestrrat-go/blackmagic"]

     

       308
       308
       -
           version = "v1.0.4"

     

       309
       309
       -
           hash = "sha256-HmWOpwoPDNMwLdOi7onNn3Sb+ZsAa3Ai3gVBbXmQ0e8="

     

       310
       310
       -
         [mod."github.com/lestrrat-go/httpcc"]

     

       311
       311
       -
           version = "v1.0.1"

     

       312
       312
       -
           hash = "sha256-SMRSwJpqDIs/xL0l2e8vP0W65qtCHX2wigcOeqPJmos="

     

       313
       313
       -
         [mod."github.com/lestrrat-go/httprc"]

     

       314
       314
       -
           version = "v1.0.6"

     

       315
       315
       -
           hash = "sha256-mfZzePEhrmyyu/avEBd2MsDXyto8dq5+fyu5lA8GUWM="

     

       316
       316
       -
         [mod."github.com/lestrrat-go/iter"]

     

       317
       317
       -
           version = "v1.0.2"

     

       318
       318
       -
           hash = "sha256-30tErRf7Qu/NOAt1YURXY/XJSA6sCr6hYQfO8QqHrtw="

     

       319
       319
       -
         [mod."github.com/lestrrat-go/jwx/v2"]

     

       320
       320
       -
           version = "v2.1.6"

     

       321
       321
       -
           hash = "sha256-0LszXRZIba+X8AOrs3T4uanAUafBdlVB8/MpUNEFpbc="

     

       322
       322
       -
         [mod."github.com/lestrrat-go/option"]

     

       323
       323
       -
           version = "v1.0.1"

     

       324
       324
       -
           hash = "sha256-jVcIYYVsxElIS/l2akEw32vdEPR8+anR6oeT1FoYULI="

     

       325
       373
        
         [mod."github.com/lucasb-eyer/go-colorful"]

     

       326
       374
        
           version = "v1.2.0"

     

       327
       375
        
           hash = "sha256-Gg9dDJFCTaHrKHRR1SrJgZ8fWieJkybljybkI9x0gyE="

     
···

       352
       400
        
         [mod."github.com/moby/term"]

     

       353
       401
        
           version = "v0.5.2"

     

       354
       402
        
           hash = "sha256-/G20jUZKx36ktmPU/nEw/gX7kRTl1Dbu7zvNBYNt4xU="

     

       403
       403
       +
         [mod."github.com/modern-go/concurrent"]

     

       404
       404
       +
           version = "v0.0.0-20180306012644-bacd9c7ef1dd"

     

       405
       405
       +
           hash = "sha256-OTySieAgPWR4oJnlohaFTeK1tRaVp/b0d1rYY8xKMzo="

     

       406
       406
       +
         [mod."github.com/modern-go/reflect2"]

     

       407
       407
       +
           version = "v1.0.2"

     

       408
       408
       +
           hash = "sha256-+W9EIW7okXIXjWEgOaMh58eLvBZ7OshW2EhaIpNLSBU="

     

       355
       409
        
         [mod."github.com/morikuni/aec"]

     

       356
       410
        
           version = "v1.0.0"

     

       357
       411
        
           hash = "sha256-5zYgLeGr3K+uhGKlN3xv0PO67V+2Zw+cezjzNCmAWOE="

     

       358
       412
        
         [mod."github.com/mr-tron/base58"]

     

       359
       413
        
           version = "v1.2.0"

     

       360
       414
        
           hash = "sha256-8FzMu3kHUbBX10pUdtGf59Ag7BNupx8ZHeUaodR1/Vk="

     

       415
       415
       +
         [mod."github.com/mschoch/smat"]

     

       416
       416
       +
           version = "v0.2.0"

     

       417
       417
       +
           hash = "sha256-DZvUJXjIcta3U+zxzgU3wpoGn/V4lpBY7Xme8aQUi+E="

     

       361
       418
        
         [mod."github.com/muesli/termenv"]

     

       362
       419
        
           version = "v0.16.0"

     

       363
       420
        
           hash = "sha256-hGo275DJlyLtcifSLpWnk8jardOksdeX9lH4lBeE3gI="

     
···

       433
       490
        
         [mod."github.com/ryanuber/go-glob"]

     

       434
       491
        
           version = "v1.0.0"

     

       435
       492
        
           hash = "sha256-YkMl1utwUhi3E0sHK23ISpAsPyj4+KeXyXKoFYGXGVY="

     

       436
       436
       -
         [mod."github.com/segmentio/asm"]

     

       437
       437
       -
           version = "v1.2.0"

     

       438
       438
       -
           hash = "sha256-zbNuKxNrUDUc6IlmRQNuJQzVe5Ol/mqp7srDg9IMMqs="

     

       439
       493
        
         [mod."github.com/sergi/go-diff"]

     

       440
       494
        
           version = "v1.1.0"

     

       441
       495
        
           hash = "sha256-8NJMabldpf40uwQN20T6QXx5KORDibCBJL02KD661xY="

     
···

       470
       524
        
         [mod."github.com/whyrusleeping/cbor-gen"]

     

       471
       525
        
           version = "v0.3.1"

     

       472
       526
        
           hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc="

     

       473
       473
       -
         [mod."github.com/wyatt915/goldmark-treeblood"]

     

       474
       474
       -
           version = "v0.0.0-20250825231212-5dcbdb2f4b57"

     

       475
       475
       -
           hash = "sha256-IZEsUXTBTsNgWoD7vqRUc9aFCCHNjzk1IUmI9O+NCnM="

     

       476
       476
       -
         [mod."github.com/wyatt915/treeblood"]

     

       477
       477
       -
           version = "v0.1.15"

     

       478
       478
       -
           hash = "sha256-hb99exdkoY2Qv8WdDxhwgPXGbEYimUr6wFtPXEvcO9g="

     

       479
       527
        
         [mod."github.com/xo/terminfo"]

     

       480
       528
        
           version = "v0.0.0-20220910002029-abceb7e1c41e"

     

       481
       529
        
           hash = "sha256-GyCDxxMQhXA3Pi/TsWXpA8cX5akEoZV7CFx4RO3rARU="

     
···

       494
       542
        
         [mod."gitlab.com/yawning/tuplehash"]

     

       495
       543
        
           version = "v0.0.0-20230713102510-df83abbf9a02"

     

       496
       544
        
           hash = "sha256-pehQduoaJRLchebhgvMYacVvbuNIBA++XkiqCuqdato="

     

       545
       545
       +
         [mod."go.etcd.io/bbolt"]

     

       546
       546
       +
           version = "v1.4.0"

     

       547
       547
       +
           hash = "sha256-nR/YGQjwz6ue99IFbgw/01Pl8PhoOjpKiwVy5sJxlps="

     

       497
       548
        
         [mod."go.opentelemetry.io/auto/sdk"]

     

       498
       549
        
           version = "v1.1.0"

     

       499
       550
        
           hash = "sha256-cA9qCCu8P1NSJRxgmpfkfa5rKyn9X+Y/9FSmSd5xjyo="

+285 -18

nix/modules/appview.nix

···

       3
       3
        
         lib,

     

       4
       4
        
         ...

     

       5
       5
        
       }: let

     

       6
       6
       -
         cfg = config.services.tangled-appview;

     

       6
       6
       +
         cfg = config.services.tangled.appview;

     

       7
       7
        
       in

     

       8
       8
        
         with lib; {

     

       9
       9
        
           options = {

     

       10
       10
       -
             services.tangled-appview = {

     

       10
       10
       +
             services.tangled.appview = {

     

       11
       11
        
               enable = mkOption {

     

       12
       12
        
                 type = types.bool;

     

       13
       13
        
                 default = false;

     

       14
       14
        
                 description = "Enable tangled appview";

     

       15
       15
        
               };

     

       16
       16
       +
       

     

       16
       17
        
               package = mkOption {

     

       17
       18
        
                 type = types.package;

     

       18
       19
        
                 description = "Package to use for the appview";

     

       19
       20
        
               };

     

       21
       21
       +
       

     

       22
       22
       +
               # core configuration

     

       20
       23
        
               port = mkOption {

     

       21
       21
       -
                 type = types.int;

     

       24
       24
       +
                 type = types.port;

     

       22
       25
        
                 default = 3000;

     

       23
       26
        
                 description = "Port to run the appview on";

     

       24
       27
        
               };

     

       25
       25
       -
               cookie_secret = mkOption {

     

       28
       28
       +
       

     

       29
       29
       +
               listenAddr = mkOption {

     

       30
       30
       +
                 type = types.str;

     

       31
       31
       +
                 default = "0.0.0.0:${toString cfg.port}";

     

       32
       32
       +
                 description = "Listen address for the appview service";

     

       33
       33
       +
               };

     

       34
       34
       +
       

     

       35
       35
       +
               dbPath = mkOption {

     

       26
       36
        
                 type = types.str;

     

       27
       27
       -
                 default = "00000000000000000000000000000000";

     

       28
       28
       -
                 description = "Cookie secret";

     

       37
       37
       +
                 default = "/var/lib/appview/appview.db";

     

       38
       38
       +
                 description = "Path to the SQLite database file";

     

       39
       39
       +
               };

     

       40
       40
       +
       

     

       41
       41
       +
               appviewHost = mkOption {

     

       42
       42
       +
                 type = types.str;

     

       43
       43
       +
                 default = "https://tangled.org";

     

       44
       44
       +
                 example = "https://example.com";

     

       45
       45
       +
                 description = "Public host URL for the appview instance";

     

       46
       46
       +
               };

     

       47
       47
       +
       

     

       48
       48
       +
               appviewName = mkOption {

     

       49
       49
       +
                 type = types.str;

     

       50
       50
       +
                 default = "Tangled";

     

       51
       51
       +
                 description = "Display name for the appview instance";

     

       52
       52
       +
               };

     

       53
       53
       +
       

     

       54
       54
       +
               dev = mkOption {

     

       55
       55
       +
                 type = types.bool;

     

       56
       56
       +
                 default = false;

     

       57
       57
       +
                 description = "Enable development mode";

     

       58
       58
       +
               };

     

       59
       59
       +
       

     

       60
       60
       +
               disallowedNicknamesFile = mkOption {

     

       61
       61
       +
                 type = types.nullOr types.path;

     

       62
       62
       +
                 default = null;

     

       63
       63
       +
                 description = "Path to file containing disallowed nicknames";

     

       64
       64
       +
               };

     

       65
       65
       +
       

     

       66
       66
       +
               # redis configuration

     

       67
       67
       +
               redis = {

     

       68
       68
       +
                 addr = mkOption {

     

       69
       69
       +
                   type = types.str;

     

       70
       70
       +
                   default = "localhost:6379";

     

       71
       71
       +
                   description = "Redis server address";

     

       72
       72
       +
                 };

     

       73
       73
       +
       

     

       74
       74
       +
                 db = mkOption {

     

       75
       75
       +
                   type = types.int;

     

       76
       76
       +
                   default = 0;

     

       77
       77
       +
                   description = "Redis database number";

     

       78
       78
       +
                 };

     

       79
       79
       +
               };

     

       80
       80
       +
       

     

       81
       81
       +
               # jetstream configuration

     

       82
       82
       +
               jetstream = {

     

       83
       83
       +
                 endpoint = mkOption {

     

       84
       84
       +
                   type = types.str;

     

       85
       85
       +
                   default = "wss://jetstream1.us-east.bsky.network/subscribe";

     

       86
       86
       +
                   description = "Jetstream WebSocket endpoint";

     

       87
       87
       +
                 };

     

       88
       88
       +
               };

     

       89
       89
       +
       

     

       90
       90
       +
               # knotstream consumer configuration

     

       91
       91
       +
               knotstream = {

     

       92
       92
       +
                 retryInterval = mkOption {

     

       93
       93
       +
                   type = types.str;

     

       94
       94
       +
                   default = "60s";

     

       95
       95
       +
                   description = "Initial retry interval for knotstream consumer";

     

       96
       96
       +
                 };

     

       97
       97
       +
       

     

       98
       98
       +
                 maxRetryInterval = mkOption {

     

       99
       99
       +
                   type = types.str;

     

       100
       100
       +
                   default = "120m";

     

       101
       101
       +
                   description = "Maximum retry interval for knotstream consumer";

     

       102
       102
       +
                 };

     

       103
       103
       +
       

     

       104
       104
       +
                 connectionTimeout = mkOption {

     

       105
       105
       +
                   type = types.str;

     

       106
       106
       +
                   default = "5s";

     

       107
       107
       +
                   description = "Connection timeout for knotstream consumer";

     

       108
       108
       +
                 };

     

       109
       109
       +
       

     

       110
       110
       +
                 workerCount = mkOption {

     

       111
       111
       +
                   type = types.int;

     

       112
       112
       +
                   default = 64;

     

       113
       113
       +
                   description = "Number of workers for knotstream consumer";

     

       114
       114
       +
                 };

     

       115
       115
       +
       

     

       116
       116
       +
                 queueSize = mkOption {

     

       117
       117
       +
                   type = types.int;

     

       118
       118
       +
                   default = 100;

     

       119
       119
       +
                   description = "Queue size for knotstream consumer";

     

       120
       120
       +
                 };

     

       121
       121
       +
               };

     

       122
       122
       +
       

     

       123
       123
       +
               # spindlestream consumer configuration

     

       124
       124
       +
               spindlestream = {

     

       125
       125
       +
                 retryInterval = mkOption {

     

       126
       126
       +
                   type = types.str;

     

       127
       127
       +
                   default = "60s";

     

       128
       128
       +
                   description = "Initial retry interval for spindlestream consumer";

     

       129
       129
       +
                 };

     

       130
       130
       +
       

     

       131
       131
       +
                 maxRetryInterval = mkOption {

     

       132
       132
       +
                   type = types.str;

     

       133
       133
       +
                   default = "120m";

     

       134
       134
       +
                   description = "Maximum retry interval for spindlestream consumer";

     

       135
       135
       +
                 };

     

       136
       136
       +
       

     

       137
       137
       +
                 connectionTimeout = mkOption {

     

       138
       138
       +
                   type = types.str;

     

       139
       139
       +
                   default = "5s";

     

       140
       140
       +
                   description = "Connection timeout for spindlestream consumer";

     

       141
       141
       +
                 };

     

       142
       142
       +
       

     

       143
       143
       +
                 workerCount = mkOption {

     

       144
       144
       +
                   type = types.int;

     

       145
       145
       +
                   default = 64;

     

       146
       146
       +
                   description = "Number of workers for spindlestream consumer";

     

       147
       147
       +
                 };

     

       148
       148
       +
       

     

       149
       149
       +
                 queueSize = mkOption {

     

       150
       150
       +
                   type = types.int;

     

       151
       151
       +
                   default = 100;

     

       152
       152
       +
                   description = "Queue size for spindlestream consumer";

     

       153
       153
       +
                 };

     

       154
       154
       +
               };

     

       155
       155
       +
       

     

       156
       156
       +
               # resend configuration

     

       157
       157
       +
               resend = {

     

       158
       158
       +
                 sentFrom = mkOption {

     

       159
       159
       +
                   type = types.str;

     

       160
       160
       +
                   default = "noreply@notifs.tangled.sh";

     

       161
       161
       +
                   description = "Email address to send notifications from";

     

       162
       162
       +
                 };

     

       163
       163
       +
               };

     

       164
       164
       +
       

     

       165
       165
       +
               # posthog configuration

     

       166
       166
       +
               posthog = {

     

       167
       167
       +
                 endpoint = mkOption {

     

       168
       168
       +
                   type = types.str;

     

       169
       169
       +
                   default = "https://eu.i.posthog.com";

     

       170
       170
       +
                   description = "PostHog API endpoint";

     

       171
       171
       +
                 };

     

       172
       172
       +
               };

     

       173
       173
       +
       

     

       174
       174
       +
               # camo configuration

     

       175
       175
       +
               camo = {

     

       176
       176
       +
                 host = mkOption {

     

       177
       177
       +
                   type = types.str;

     

       178
       178
       +
                   default = "https://camo.tangled.sh";

     

       179
       179
       +
                   description = "Camo proxy host URL";

     

       180
       180
       +
                 };

     

       29
       181
        
               };

     

       182
       182
       +
       

     

       183
       183
       +
               # avatar configuration

     

       184
       184
       +
               avatar = {

     

       185
       185
       +
                 host = mkOption {

     

       186
       186
       +
                   type = types.str;

     

       187
       187
       +
                   default = "https://avatar.tangled.sh";

     

       188
       188
       +
                   description = "Avatar service host URL";

     

       189
       189
       +
                 };

     

       190
       190
       +
               };

     

       191
       191
       +
       

     

       192
       192
       +
               plc = {

     

       193
       193
       +
                 url = mkOption {

     

       194
       194
       +
                   type = types.str;

     

       195
       195
       +
                   default = "https://plc.directory";

     

       196
       196
       +
                   description = "PLC directory URL";

     

       197
       197
       +
                 };

     

       198
       198
       +
               };

     

       199
       199
       +
       

     

       200
       200
       +
               pds = {

     

       201
       201
       +
                 host = mkOption {

     

       202
       202
       +
                   type = types.str;

     

       203
       203
       +
                   default = "https://tngl.sh";

     

       204
       204
       +
                   description = "PDS host URL";

     

       205
       205
       +
                 };

     

       206
       206
       +
               };

     

       207
       207
       +
       

     

       208
       208
       +
               label = {

     

       209
       209
       +
                 defaults = mkOption {

     

       210
       210
       +
                   type = types.listOf types.str;

     

       211
       211
       +
                   default = [

     

       212
       212
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/wontfix"

     

       213
       213
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue"

     

       214
       214
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/duplicate"

     

       215
       215
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/documentation"

     

       216
       216
       +
                     "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/assignee"

     

       217
       217
       +
                   ];

     

       218
       218
       +
                   description = "Default label definitions";

     

       219
       219
       +
                 };

     

       220
       220
       +
       

     

       221
       221
       +
                 goodFirstIssue = mkOption {

     

       222
       222
       +
                   type = types.str;

     

       223
       223
       +
                   default = "at://did:plc:wshs7t2adsemcrrd4snkeqli/sh.tangled.label.definition/good-first-issue";

     

       224
       224
       +
                   description = "Good first issue label definition";

     

       225
       225
       +
                 };

     

       226
       226
       +
               };

     

       227
       227
       +
       

     

       30
       228
        
               environmentFile = mkOption {

     

       31
       229
        
                 type = with types; nullOr path;

     

       32
       230
        
                 default = null;

     

       33
       33
       -
                 example = "/etc/tangled-appview.env";

     

       231
       231
       +
                 example = "/etc/appview.env";

     

       34
       232
        
                 description = ''

     

       35
       233
        
                   Additional environment file as defined in {manpage}`systemd.exec(5)`.

     

       36
       234
        
       

     

       37
       37
       -
                   Sensitive secrets such as {env}`TANGLED_COOKIE_SECRET` may be

     

       38
       38
       -
                   passed to the service without makeing them world readable in the

     

       39
       39
       -
                   nix store.

     

       40
       40
       -
       

     

       235
       235
       +
                   Sensitive secrets such as {env}`TANGLED_COOKIE_SECRET`,

     

       236
       236
       +
                   {env}`TANGLED_OAUTH_CLIENT_SECRET`, {env}`TANGLED_RESEND_API_KEY`,

     

       237
       237
       +
                   {env}`TANGLED_CAMO_SHARED_SECRET`, {env}`TANGLED_AVATAR_SHARED_SECRET`,

     

       238
       238
       +
                   {env}`TANGLED_REDIS_PASS`, {env}`TANGLED_PDS_ADMIN_SECRET`,

     

       239
       239
       +
                   {env}`TANGLED_CLOUDFLARE_API_TOKEN`, {env}`TANGLED_CLOUDFLARE_ZONE_ID`,

     

       240
       240
       +
                   {env}`TANGLED_CLOUDFLARE_TURNSTILE_SITE_KEY`,

     

       241
       241
       +
                   {env}`TANGLED_CLOUDFLARE_TURNSTILE_SECRET_KEY`,

     

       242
       242
       +
                   {env}`TANGLED_POSTHOG_API_KEY`, {env}`TANGLED_APP_PASSWORD`,

     

       243
       243
       +
                   and {env}`TANGLED_ALT_APP_PASSWORD` may be passed to the service

     

       244
       244
       +
                   without making them world readable in the nix store.

     

       41
       245
        
                 '';

     

       42
       246
        
               };

     

       43
       247
        
             };

     

       44
       248
        
           };

     

       45
       249
        
       

     

       46
       250
        
           config = mkIf cfg.enable {

     

       47
       47
       -
             systemd.services.tangled-appview = {

     

       251
       251
       +
             services.redis.servers.appview = {

     

       252
       252
       +
               enable = true;

     

       253
       253
       +
               port = 6379;

     

       254
       254
       +
             };

     

       255
       255
       +
       

     

       256
       256
       +
             systemd.services.appview = {

     

       48
       257
        
               description = "tangled appview service";

     

       49
       258
        
               wantedBy = ["multi-user.target"];

     

       259
       259
       +
               after = ["redis-appview.service" "network-online.target"];

     

       260
       260
       +
               requires = ["redis-appview.service"];

     

       261
       261
       +
               wants = ["network-online.target"];

     

       50
       262
        
       

     

       51
       263
        
               serviceConfig = {

     

       52
       52
       -
                 ListenStream = "0.0.0.0:${toString cfg.port}";

     

       264
       264
       +
                 Type = "simple";

     

       53
       265
        
                 ExecStart = "${cfg.package}/bin/appview";

     

       54
       266
        
                 Restart = "always";

     

       55
       55
       -
                 EnvironmentFile = optional (cfg.environmentFile != null) cfg.environmentFile;

     

       267
       267
       +
                 RestartSec = "10s";

     

       268
       268
       +
                 EnvironmentFile = mkIf (cfg.environmentFile != null) cfg.environmentFile;

     

       269
       269
       +
       

     

       270
       270
       +
                 # state directory

     

       271
       271
       +
                 StateDirectory = "appview";

     

       272
       272
       +
                 WorkingDirectory = "/var/lib/appview";

     

       273
       273
       +
       

     

       274
       274
       +
                 # security hardening

     

       275
       275
       +
                 NoNewPrivileges = true;

     

       276
       276
       +
                 PrivateTmp = true;

     

       277
       277
       +
                 ProtectSystem = "strict";

     

       278
       278
       +
                 ProtectHome = true;

     

       279
       279
       +
                 ReadWritePaths = ["/var/lib/appview"];

     

       56
       280
        
               };

     

       57
       281
        
       

     

       58
       58
       -
               environment = {

     

       59
       59
       -
                 TANGLED_DB_PATH = "appview.db";

     

       60
       60
       -
                 TANGLED_COOKIE_SECRET = cfg.cookie_secret;

     

       61
       61
       -
               };

     

       282
       282
       +
               environment =

     

       283
       283
       +
                 {

     

       284
       284
       +
                   TANGLED_DB_PATH = cfg.dbPath;

     

       285
       285
       +
                   TANGLED_LISTEN_ADDR = cfg.listenAddr;

     

       286
       286
       +
                   TANGLED_APPVIEW_HOST = cfg.appviewHost;

     

       287
       287
       +
                   TANGLED_APPVIEW_NAME = cfg.appviewName;

     

       288
       288
       +
                   TANGLED_DEV =

     

       289
       289
       +
                     if cfg.dev

     

       290
       290
       +
                     then "true"

     

       291
       291
       +
                     else "false";

     

       292
       292
       +
                 }

     

       293
       293
       +
                 // optionalAttrs (cfg.disallowedNicknamesFile != null) {

     

       294
       294
       +
                   TANGLED_DISALLOWED_NICKNAMES_FILE = cfg.disallowedNicknamesFile;

     

       295
       295
       +
                 }

     

       296
       296
       +
                 // {

     

       297
       297
       +
                   TANGLED_REDIS_ADDR = cfg.redis.addr;

     

       298
       298
       +
                   TANGLED_REDIS_DB = toString cfg.redis.db;

     

       299
       299
       +
       

     

       300
       300
       +
                   TANGLED_JETSTREAM_ENDPOINT = cfg.jetstream.endpoint;

     

       301
       301
       +
       

     

       302
       302
       +
                   TANGLED_KNOTSTREAM_RETRY_INTERVAL = cfg.knotstream.retryInterval;

     

       303
       303
       +
                   TANGLED_KNOTSTREAM_MAX_RETRY_INTERVAL = cfg.knotstream.maxRetryInterval;

     

       304
       304
       +
                   TANGLED_KNOTSTREAM_CONNECTION_TIMEOUT = cfg.knotstream.connectionTimeout;

     

       305
       305
       +
                   TANGLED_KNOTSTREAM_WORKER_COUNT = toString cfg.knotstream.workerCount;

     

       306
       306
       +
                   TANGLED_KNOTSTREAM_QUEUE_SIZE = toString cfg.knotstream.queueSize;

     

       307
       307
       +
       

     

       308
       308
       +
                   TANGLED_SPINDLESTREAM_RETRY_INTERVAL = cfg.spindlestream.retryInterval;

     

       309
       309
       +
                   TANGLED_SPINDLESTREAM_MAX_RETRY_INTERVAL = cfg.spindlestream.maxRetryInterval;

     

       310
       310
       +
                   TANGLED_SPINDLESTREAM_CONNECTION_TIMEOUT = cfg.spindlestream.connectionTimeout;

     

       311
       311
       +
                   TANGLED_SPINDLESTREAM_WORKER_COUNT = toString cfg.spindlestream.workerCount;

     

       312
       312
       +
                   TANGLED_SPINDLESTREAM_QUEUE_SIZE = toString cfg.spindlestream.queueSize;

     

       313
       313
       +
       

     

       314
       314
       +
                   TANGLED_RESEND_SENT_FROM = cfg.resend.sentFrom;

     

       315
       315
       +
       

     

       316
       316
       +
                   TANGLED_POSTHOG_ENDPOINT = cfg.posthog.endpoint;

     

       317
       317
       +
       

     

       318
       318
       +
                   TANGLED_CAMO_HOST = cfg.camo.host;

     

       319
       319
       +
       

     

       320
       320
       +
                   TANGLED_AVATAR_HOST = cfg.avatar.host;

     

       321
       321
       +
       

     

       322
       322
       +
                   TANGLED_PLC_URL = cfg.plc.url;

     

       323
       323
       +
       

     

       324
       324
       +
                   TANGLED_PDS_HOST = cfg.pds.host;

     

       325
       325
       +
       

     

       326
       326
       +
                   TANGLED_LABEL_DEFAULTS = concatStringsSep "," cfg.label.defaults;

     

       327
       327
       +
                   TANGLED_LABEL_GFI = cfg.label.goodFirstIssue;

     

       328
       328
       +
                 };

     

       62
       329
        
             };

     

       63
       330
        
           };

     

       64
       331
        
         }

+76 -4

nix/modules/knot.nix

···

       4
       4
        
         lib,

     

       5
       5
        
         ...

     

       6
       6
        
       }: let

     

       7
       7
       -
         cfg = config.services.tangled-knot;

     

       7
       7
       +
         cfg = config.services.tangled.knot;

     

       8
       8
        
       in

     

       9
       9
        
         with lib; {

     

       10
       10
        
           options = {

     

       11
       11
       -
             services.tangled-knot = {

     

       11
       11
       +
             services.tangled.knot = {

     

       12
       12
        
               enable = mkOption {

     

       13
       13
        
                 type = types.bool;

     

       14
       14
        
                 default = false;

     
···

       51
       51
        
                   description = "Path where repositories are scanned from";

     

       52
       52
        
                 };

     

       53
       53
        
       

     

       54
       54
       +
                 readme = mkOption {

     

       55
       55
       +
                   type = types.listOf types.str;

     

       56
       56
       +
                   default = [

     

       57
       57
       +
                     "README.md"

     

       58
       58
       +
                     "readme.md"

     

       59
       59
       +
                     "README"

     

       60
       60
       +
                     "readme"

     

       61
       61
       +
                     "README.markdown"

     

       62
       62
       +
                     "readme.markdown"

     

       63
       63
       +
                     "README.txt"

     

       64
       64
       +
                     "readme.txt"

     

       65
       65
       +
                     "README.rst"

     

       66
       66
       +
                     "readme.rst"

     

       67
       67
       +
                     "README.org"

     

       68
       68
       +
                     "readme.org"

     

       69
       69
       +
                     "README.asciidoc"

     

       70
       70
       +
                     "readme.asciidoc"

     

       71
       71
       +
                   ];

     

       72
       72
       +
                   description = "List of README filenames to look for (in priority order)";

     

       73
       73
       +
                 };

     

       74
       74
       +
       

     

       54
       75
        
                 mainBranch = mkOption {

     

       55
       76
        
                   type = types.str;

     

       56
       77
        
                   default = "main";

     

       57
       78
        
                   description = "Default branch name for repositories";

     

       79
       79
       +
                 };

     

       80
       80
       +
               };

     

       81
       81
       +
       

     

       82
       82
       +
               git = {

     

       83
       83
       +
                 userName = mkOption {

     

       84
       84
       +
                   type = types.str;

     

       85
       85
       +
                   default = "Tangled";

     

       86
       86
       +
                   description = "Git user name used as committer";

     

       87
       87
       +
                 };

     

       88
       88
       +
       

     

       89
       89
       +
                 userEmail = mkOption {

     

       90
       90
       +
                   type = types.str;

     

       91
       91
       +
                   default = "noreply@tangled.org";

     

       92
       92
       +
                   description = "Git user email used as committer";

     

       58
       93
        
                 };

     

       59
       94
        
               };

     

       60
       95
        
       

     
···

       111
       146
        
                   description = "Hostname for the server (required)";

     

       112
       147
        
                 };

     

       113
       148
        
       

     

       149
       149
       +
                 plcUrl = mkOption {

     

       150
       150
       +
                   type = types.str;

     

       151
       151
       +
                   default = "https://plc.directory";

     

       152
       152
       +
                   description = "atproto PLC directory";

     

       153
       153
       +
                 };

     

       154
       154
       +
       

     

       155
       155
       +
                 jetstreamEndpoint = mkOption {

     

       156
       156
       +
                   type = types.str;

     

       157
       157
       +
                   default = "wss://jetstream1.us-west.bsky.network/subscribe";

     

       158
       158
       +
                   description = "Jetstream endpoint to subscribe to";

     

       159
       159
       +
                 };

     

       160
       160
       +
       

     

       161
       161
       +
                 logDids = mkOption {

     

       162
       162
       +
                   type = types.bool;

     

       163
       163
       +
                   default = true;

     

       164
       164
       +
                   description = "Enable logging of DIDs";

     

       165
       165
       +
                 };

     

       166
       166
       +
       

     

       114
       167
        
                 dev = mkOption {

     

       115
       168
        
                   type = types.bool;

     

       116
       169
        
                   default = false;

     
···

       142
       195
        
                 Match User ${cfg.gitUser}

     

       143
       196
        
                     AuthorizedKeysCommand /etc/ssh/keyfetch_wrapper

     

       144
       197
        
                     AuthorizedKeysCommandUser nobody

     

       198
       198
       +
                     ChallengeResponseAuthentication no

     

       199
       199
       +
                     PasswordAuthentication no

     

       145
       200
        
               '';

     

       146
       201
        
             };

     

       147
       202
        
       

     
···

       178
       233
        
                 mkdir -p "${cfg.stateDir}/.config/git"

     

       179
       234
        
                 cat > "${cfg.stateDir}/.config/git/config" << EOF

     

       180
       235
        
                 [user]

     

       181
       181
       -
                     name = Git User

     

       182
       182
       -
                     email = git@example.com

     

       236
       236
       +
                     name = ${cfg.git.userName}

     

       237
       237
       +
                     email = ${cfg.git.userEmail}

     

       183
       238
        
                 [receive]

     

       184
       239
        
                     advertisePushOptions = true

     

       240
       240
       +
                 [uploadpack]

     

       241
       241
       +
                     allowFilter = true

     

       185
       242
        
                 EOF

     

       186
       243
        
                 ${setMotd}

     

       187
       244
        
                 chown -R ${cfg.gitUser}:${cfg.gitUser} "${cfg.stateDir}"

     
···

       193
       250
        
                 WorkingDirectory = cfg.stateDir;

     

       194
       251
        
                 Environment = [

     

       195
       252
        
                   "KNOT_REPO_SCAN_PATH=${cfg.repo.scanPath}"

     

       253
       253
       +
                   "KNOT_REPO_README=${concatStringsSep "," cfg.repo.readme}"

     

       196
       254
        
                   "KNOT_REPO_MAIN_BRANCH=${cfg.repo.mainBranch}"

     

       255
       255
       +
                   "KNOT_GIT_USER_NAME=${cfg.git.userName}"

     

       256
       256
       +
                   "KNOT_GIT_USER_EMAIL=${cfg.git.userEmail}"

     

       197
       257
        
                   "APPVIEW_ENDPOINT=${cfg.appviewEndpoint}"

     

       198
       258
        
                   "KNOT_SERVER_INTERNAL_LISTEN_ADDR=${cfg.server.internalListenAddr}"

     

       199
       259
        
                   "KNOT_SERVER_LISTEN_ADDR=${cfg.server.listenAddr}"

     

       200
       260
        
                   "KNOT_SERVER_DB_PATH=${cfg.server.dbPath}"

     

       201
       261
        
                   "KNOT_SERVER_HOSTNAME=${cfg.server.hostname}"

     

       262
       262
       +
                   "KNOT_SERVER_PLC_URL=${cfg.server.plcUrl}"

     

       263
       263
       +
                   "KNOT_SERVER_JETSTREAM_ENDPOINT=${cfg.server.jetstreamEndpoint}"

     

       202
       264
        
                   "KNOT_SERVER_OWNER=${cfg.server.owner}"

     

       265
       265
       +
                   "KNOT_SERVER_LOG_DIDS=${

     

       266
       266
       +
                     if cfg.server.logDids

     

       267
       267
       +
                     then "true"

     

       268
       268
       +
                     else "false"

     

       269
       269
       +
                   }"

     

       270
       270
       +
                   "KNOT_SERVER_DEV=${

     

       271
       271
       +
                     if cfg.server.dev

     

       272
       272
       +
                     then "true"

     

       273
       273
       +
                     else "false"

     

       274
       274
       +
                   }"

     

       203
       275
        
                 ];

     

       204
       276
        
                 ExecStart = "${cfg.package}/bin/knot server";

     

       205
       277
        
                 Restart = "always";

+10 -3

nix/modules/spindle.nix

···

       3
       3
        
         lib,

     

       4
       4
        
         ...

     

       5
       5
        
       }: let

     

       6
       6
       -
         cfg = config.services.tangled-spindle;

     

       6
       6
       +
         cfg = config.services.tangled.spindle;

     

       7
       7
        
       in

     

       8
       8
        
         with lib; {

     

       9
       9
        
           options = {

     

       10
       10
       -
             services.tangled-spindle = {

     

       10
       10
       +
             services.tangled.spindle = {

     

       11
       11
        
               enable = mkOption {

     

       12
       12
        
                 type = types.bool;

     

       13
       13
        
                 default = false;

     
···

       35
       35
        
                   type = types.str;

     

       36
       36
        
                   example = "my.spindle.com";

     

       37
       37
        
                   description = "Hostname for the server (required)";

     

       38
       38
       +
                 };

     

       39
       39
       +
       

     

       40
       40
       +
                 plcUrl = mkOption {

     

       41
       41
       +
                   type = types.str;

     

       42
       42
       +
                   default = "https://plc.directory";

     

       43
       43
       +
                   description = "atproto PLC directory";

     

       38
       44
        
                 };

     

       39
       45
        
       

     

       40
       46
        
                 jetstreamEndpoint = mkOption {

     
···

       119
       125
        
                   "SPINDLE_SERVER_LISTEN_ADDR=${cfg.server.listenAddr}"

     

       120
       126
        
                   "SPINDLE_SERVER_DB_PATH=${cfg.server.dbPath}"

     

       121
       127
        
                   "SPINDLE_SERVER_HOSTNAME=${cfg.server.hostname}"

     

       122
       122
       -
                   "SPINDLE_SERVER_JETSTREAM=${cfg.server.jetstreamEndpoint}"

     

       128
       128
       +
                   "SPINDLE_SERVER_PLC_URL=${cfg.server.plcUrl}"

     

       129
       129
       +
                   "SPINDLE_SERVER_JETSTREAM_ENDPOINT=${cfg.server.jetstreamEndpoint}"

     

       123
       130
        
                   "SPINDLE_SERVER_DEV=${lib.boolToString cfg.server.dev}"

     

       124
       131
        
                   "SPINDLE_SERVER_OWNER=${cfg.server.owner}"

     

       125
       132
        
                   "SPINDLE_SERVER_MAX_JOB_COUNT=${toString cfg.server.maxJobCount}"

nix/pkgs/appview-static-files.nix

···

       5
       5
        
         lucide-src,

     

       6
       6
        
         inter-fonts-src,

     

       7
       7
        
         ibm-plex-mono-src,

     

       8
       8
       +
         actor-typeahead-src,

     

       8
       9
        
         sqlite-lib,

     

       9
       10
        
         tailwindcss,

     

       10
       11
        
         src,

     
···

       24
       25
        
         cp -f ${inter-fonts-src}/web/InterDisplay*.woff2 fonts/

     

       25
       26
        
         cp -f ${inter-fonts-src}/InterVariable*.ttf fonts/

     

       26
       27
        
         cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono*.woff2 fonts/

     

       28
       28
       +
         cp -f ${actor-typeahead-src}/actor-typeahead.js .

     

       27
       29
        
         # tailwindcss -c $src/tailwind.config.js -i $src/input.css -o tw.css won't work

     

       28
       30
        
         # for whatever reason (produces broken css), so we are doing this instead

     

       29
       31
        
         cd ${src} && ${tailwindcss}/bin/tailwindcss -i input.css -o $out/tw.css

-18

nix/pkgs/genjwks.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         buildGoApplication,

     

       3
       3
       -
         modules,

     

       4
       4
       -
       }:

     

       5
       5
       -
       buildGoApplication {

     

       6
       6
       -
         pname = "genjwks";

     

       7
       7
       -
         version = "0.1.0";

     

       8
       8
       -
         src = ../../cmd/genjwks;

     

       9
       9
       -
         postPatch = ''

     

       10
       10
       -
           ln -s ${../../go.mod} ./go.mod

     

       11
       11
       -
         '';

     

       12
       12
       -
         postInstall = ''

     

       13
       13
       -
           mv $out/bin/core $out/bin/genjwks

     

       14
       14
       -
         '';

     

       15
       15
       -
         inherit modules;

     

       16
       16
       -
         doCheck = false;

     

       17
       17
       -
         CGO_ENABLED = 0;

     

       18
       18
       -
       }

+12

nix/pkgs/goat.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         buildGoModule,

     

       3
       3
       +
         indigo,

     

       4
       4
       +
       }:

     

       5
       5
       +
       buildGoModule {

     

       6
       6
       +
         pname = "goat";

     

       7
       7
       +
         version = "0.1.0";

     

       8
       8
       +
         src = indigo;

     

       9
       9
       +
         subPackages = ["cmd/goat"];

     

       10
       10
       +
         vendorHash = "sha256-VbDrcN4r5b7utRFQzVsKgDsVgdQLSXl7oZ5kdPA/huw=";

     

       11
       11
       +
         doCheck = false;

     

       12
       12
       +
       }

+1 -1

nix/pkgs/knot-unwrapped.nix

···

       4
       4
        
         sqlite-lib,

     

       5
       5
        
         src,

     

       6
       6
        
       }: let

     

       7
       7
       -
         version = "1.9.1-alpha";

     

       7
       7
       +
         version = "1.11.0-alpha";

     

       8
       8
        
       in

     

       9
       9
        
         buildGoApplication {

     

       10
       10
        
           pname = "knot";

+7 -5

nix/pkgs/sqlite-lib.nix

···

       1
       1
        
       {

     

       2
       2
       -
         gcc,

     

       3
       2
        
         stdenv,

     

       4
       3
        
         sqlite-lib-src,

     

       5
       4
        
       }:

     

       6
       5
        
       stdenv.mkDerivation {

     

       7
       6
        
         name = "sqlite-lib";

     

       8
       7
        
         src = sqlite-lib-src;

     

       9
       9
       -
         nativeBuildInputs = [gcc];

     

       8
       8
       +
       

     

       10
       9
        
         buildPhase = ''

     

       11
       11
       -
           gcc -c sqlite3.c

     

       12
       12
       -
           ar rcs libsqlite3.a sqlite3.o

     

       13
       13
       -
           ranlib libsqlite3.a

     

       10
       10
       +
           $CC -c sqlite3.c

     

       11
       11
       +
           $AR rcs libsqlite3.a sqlite3.o

     

       12
       12
       +
           $RANLIB libsqlite3.a

     

       13
       13
       +
         '';

     

       14
       14
       +
       

     

       15
       15
       +
         installPhase = ''

     

       14
       16
        
           mkdir -p $out/include $out/lib

     

       15
       17
        
           cp *.h $out/include

     

       16
       18
        
           cp libsqlite3.a $out/lib

+24 -11

nix/vm.nix

···

       10
       10
        
           if var == ""

     

       11
       11
        
           then throw "\$${name} must be defined, see docs/hacking.md for more details"

     

       12
       12
        
           else var;

     

       13
       13
       +
         envVarOr = name: default: let

     

       14
       14
       +
           var = builtins.getEnv name;

     

       15
       15
       +
         in

     

       16
       16
       +
           if var != ""

     

       17
       17
       +
           then var

     

       18
       18
       +
           else default;

     

       19
       19
       +
       

     

       20
       20
       +
         plcUrl = envVarOr "TANGLED_VM_PLC_URL" "https://plc.directory";

     

       21
       21
       +
         jetstream = envVarOr "TANGLED_VM_JETSTREAM_ENDPOINT" "wss://jetstream1.us-west.bsky.network/subscribe";

     

       13
       22
        
       in

     

       14
       23
        
         nixpkgs.lib.nixosSystem {

     

       15
       24
        
           inherit system;

     
···

       39
       48
        
                   # knot

     

       40
       49
        
                   {

     

       41
       50
        
                     from = "host";

     

       42
       42
       -
                     host.port = 6000;

     

       43
       43
       -
                     guest.port = 6000;

     

       51
       51
       +
                     host.port = 6444;

     

       52
       52
       +
                     guest.port = 6444;

     

       44
       53
        
                   }

     

       45
       54
        
                   # spindle

     

       46
       55
        
                   {

     
···

       73
       82
        
               time.timeZone = "Europe/London";

     

       74
       83
        
               services.getty.autologinUser = "root";

     

       75
       84
        
               environment.systemPackages = with pkgs; [curl vim git sqlite litecli];

     

       76
       76
       -
               services.tangled-knot = {

     

       85
       85
       +
               services.tangled.knot = {

     

       77
       86
        
                 enable = true;

     

       78
       87
        
                 motd = "Welcome to the development knot!\n";

     

       79
       88
        
                 server = {

     

       80
       89
        
                   owner = envVar "TANGLED_VM_KNOT_OWNER";

     

       81
       81
       -
                   hostname = "localhost:6000";

     

       82
       82
       -
                   listenAddr = "0.0.0.0:6000";

     

       90
       90
       +
                   hostname = envVarOr "TANGLED_VM_KNOT_HOST" "localhost:6444";

     

       91
       91
       +
                   plcUrl = plcUrl;

     

       92
       92
       +
                   jetstreamEndpoint = jetstream;

     

       93
       93
       +
                   listenAddr = "0.0.0.0:6444";

     

       83
       94
        
                 };

     

       84
       95
        
               };

     

       85
       85
       -
               services.tangled-spindle = {

     

       96
       96
       +
               services.tangled.spindle = {

     

       86
       97
        
                 enable = true;

     

       87
       98
        
                 server = {

     

       88
       99
        
                   owner = envVar "TANGLED_VM_SPINDLE_OWNER";

     

       89
       89
       -
                   hostname = "localhost:6555";

     

       100
       100
       +
                   hostname = envVarOr "TANGLED_VM_SPINDLE_HOST" "localhost:6555";

     

       101
       101
       +
                   plcUrl = plcUrl;

     

       102
       102
       +
                   jetstreamEndpoint = jetstream;

     

       90
       103
        
                   listenAddr = "0.0.0.0:6555";

     

       91
       104
        
                   dev = true;

     

       92
       105
        
                   queueSize = 100;

     
···

       99
       112
        
               users = {

     

       100
       113
        
                 # So we don't have to deal with permission clashing between

     

       101
       114
        
                 # blank disk VMs and existing state

     

       102
       102
       -
                 users.${config.services.tangled-knot.gitUser}.uid = 666;

     

       103
       103
       -
                 groups.${config.services.tangled-knot.gitUser}.gid = 666;

     

       115
       115
       +
                 users.${config.services.tangled.knot.gitUser}.uid = 666;

     

       116
       116
       +
                 groups.${config.services.tangled.knot.gitUser}.gid = 666;

     

       104
       117
        
       

     

       105
       118
        
                 # TODO: separate spindle user

     

       106
       119
        
               };

     
···

       120
       133
        
                   serviceConfig.PermissionsStartOnly = true;

     

       121
       134
        
                 };

     

       122
       135
        
               in {

     

       123
       123
       -
                 knot = mkDataSyncScripts "/mnt/knot-data" config.services.tangled-knot.stateDir;

     

       124
       124
       -
                 spindle = mkDataSyncScripts "/mnt/spindle-data" (builtins.dirOf config.services.tangled-spindle.server.dbPath);

     

       136
       136
       +
                 knot = mkDataSyncScripts "/mnt/knot-data" config.services.tangled.knot.stateDir;

     

       137
       137
       +
                 spindle = mkDataSyncScripts "/mnt/spindle-data" (builtins.dirOf config.services.tangled.spindle.server.dbPath);

     

       125
       138
        
               };

     

       126
       139
        
             })

     

       127
       140
        
           ];

+122

orm/orm.go

···

       1
       1
       +
       package orm

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"database/sql"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"log/slog"

     

       8
       8
       +
       	"reflect"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       type migrationFn = func(*sql.Tx) error

     

       13
       13
       +
       

     

       14
       14
       +
       func RunMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       15
       15
       +
       	logger = logger.With("migration", name)

     

       16
       16
       +
       

     

       17
       17
       +
       	tx, err := c.BeginTx(context.Background(), nil)

     

       18
       18
       +
       	if err != nil {

     

       19
       19
       +
       		return err

     

       20
       20
       +
       	}

     

       21
       21
       +
       	defer tx.Rollback()

     

       22
       22
       +
       

     

       23
       23
       +
       	var exists bool

     

       24
       24
       +
       	err = tx.QueryRow("select exists (select 1 from migrations where name = ?)", name).Scan(&exists)

     

       25
       25
       +
       	if err != nil {

     

       26
       26
       +
       		return err

     

       27
       27
       +
       	}

     

       28
       28
       +
       

     

       29
       29
       +
       	if !exists {

     

       30
       30
       +
       		// run migration

     

       31
       31
       +
       		err = migrationFn(tx)

     

       32
       32
       +
       		if err != nil {

     

       33
       33
       +
       			logger.Error("failed to run migration", "err", err)

     

       34
       34
       +
       			return err

     

       35
       35
       +
       		}

     

       36
       36
       +
       

     

       37
       37
       +
       		// mark migration as complete

     

       38
       38
       +
       		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       39
       39
       +
       		if err != nil {

     

       40
       40
       +
       			logger.Error("failed to mark migration as complete", "err", err)

     

       41
       41
       +
       			return err

     

       42
       42
       +
       		}

     

       43
       43
       +
       

     

       44
       44
       +
       		// commit the transaction

     

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

     

       46
       46
       +
       			return err

     

       47
       47
       +
       		}

     

       48
       48
       +
       

     

       49
       49
       +
       		logger.Info("migration applied successfully")

     

       50
       50
       +
       	} else {

     

       51
       51
       +
       		logger.Warn("skipped migration, already applied")

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	return nil

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       type Filter struct {

     

       58
       58
       +
       	Key string

     

       59
       59
       +
       	arg any

     

       60
       60
       +
       	Cmp string

     

       61
       61
       +
       }

     

       62
       62
       +
       

     

       63
       63
       +
       func newFilter(key, cmp string, arg any) Filter {

     

       64
       64
       +
       	return Filter{

     

       65
       65
       +
       		Key: key,

     

       66
       66
       +
       		arg: arg,

     

       67
       67
       +
       		Cmp: cmp,

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func FilterEq(key string, arg any) Filter      { return newFilter(key, "=", arg) }

     

       72
       72
       +
       func FilterNotEq(key string, arg any) Filter   { return newFilter(key, "<>", arg) }

     

       73
       73
       +
       func FilterGte(key string, arg any) Filter     { return newFilter(key, ">=", arg) }

     

       74
       74
       +
       func FilterLte(key string, arg any) Filter     { return newFilter(key, "<=", arg) }

     

       75
       75
       +
       func FilterIs(key string, arg any) Filter      { return newFilter(key, "is", arg) }

     

       76
       76
       +
       func FilterIsNot(key string, arg any) Filter   { return newFilter(key, "is not", arg) }

     

       77
       77
       +
       func FilterIn(key string, arg any) Filter      { return newFilter(key, "in", arg) }

     

       78
       78
       +
       func FilterLike(key string, arg any) Filter    { return newFilter(key, "like", arg) }

     

       79
       79
       +
       func FilterNotLike(key string, arg any) Filter { return newFilter(key, "not like", arg) }

     

       80
       80
       +
       func FilterContains(key string, arg any) Filter {

     

       81
       81
       +
       	return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (f Filter) Condition() string {

     

       85
       85
       +
       	rv := reflect.ValueOf(f.arg)

     

       86
       86
       +
       	kind := rv.Kind()

     

       87
       87
       +
       

     

       88
       88
       +
       	// if we have `FilterIn(k, [1, 2, 3])`, compile it down to `k in (?, ?, ?)`

     

       89
       89
       +
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       90
       90
       +
       		if rv.Len() == 0 {

     

       91
       91
       +
       			// always false

     

       92
       92
       +
       			return "1 = 0"

     

       93
       93
       +
       		}

     

       94
       94
       +
       

     

       95
       95
       +
       		placeholders := make([]string, rv.Len())

     

       96
       96
       +
       		for i := range placeholders {

     

       97
       97
       +
       			placeholders[i] = "?"

     

       98
       98
       +
       		}

     

       99
       99
       +
       

     

       100
       100
       +
       		return fmt.Sprintf("%s %s (%s)", f.Key, f.Cmp, strings.Join(placeholders, ", "))

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	return fmt.Sprintf("%s %s ?", f.Key, f.Cmp)

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

       106
       106
       +
       func (f Filter) Arg() []any {

     

       107
       107
       +
       	rv := reflect.ValueOf(f.arg)

     

       108
       108
       +
       	kind := rv.Kind()

     

       109
       109
       +
       	if (kind == reflect.Slice && rv.Type().Elem().Kind() != reflect.Uint8) || kind == reflect.Array {

     

       110
       110
       +
       		if rv.Len() == 0 {

     

       111
       111
       +
       			return nil

     

       112
       112
       +
       		}

     

       113
       113
       +
       

     

       114
       114
       +
       		out := make([]any, rv.Len())

     

       115
       115
       +
       		for i := range rv.Len() {

     

       116
       116
       +
       			out[i] = rv.Index(i).Interface()

     

       117
       117
       +
       		}

     

       118
       118
       +
       		return out

     

       119
       119
       +
       	}

     

       120
       120
       +
       

     

       121
       121
       +
       	return []any{f.arg}

     

       122
       122
       +
       }

-1

patchutil/patchutil.go

···

       296
       296
        
       	}

     

       297
       297
        
       

     

       298
       298
        
       	nd := types.NiceDiff{}

     

       299
       299
       -
       	nd.Commit.Parent = targetBranch

     

       300
       299
        
       

     

       301
       300
        
       	for _, d := range diffs {

     

       302
       301
        
       		ndiff := types.Diff{}

rbac/rbac.go

···

       285
       285
        
       	return e.E.Enforce(user, domain, repo, "repo:delete")

     

       286
       286
        
       }

     

       287
       287
        
       

     

       288
       288
       +
       func (e *Enforcer) IsRepoOwner(user, domain, repo string) (bool, error) {

     

       289
       289
       +
       	return e.E.Enforce(user, domain, repo, "repo:owner")

     

       290
       290
       +
       }

     

       291
       291
       +
       

     

       292
       292
       +
       func (e *Enforcer) IsRepoCollaborator(user, domain, repo string) (bool, error) {

     

       293
       293
       +
       	return e.E.Enforce(user, domain, repo, "repo:collaborator")

     

       294
       294
       +
       }

     

       295
       295
       +
       

     

       288
       296
        
       func (e *Enforcer) IsPushAllowed(user, domain, repo string) (bool, error) {

     

       289
       297
        
       	return e.E.Enforce(user, domain, repo, "repo:push")

     

       290
       298
        
       }

-26

scripts/appview.sh

···

       1
       1
       -
       #!/bin/bash

     

       2
       2
       -
       

     

       3
       3
       -
       # Variables

     

       4
       4
       -
       BINARY_NAME="appview"

     

       5
       5
       -
       BINARY_PATH=".bin/app"

     

       6
       6
       -
       SERVER="95.111.206.63"

     

       7
       7
       -
       USER="appview"

     

       8
       8
       -
       

     

       9
       9
       -
       # SCP the binary to root's home directory

     

       10
       10
       -
       scp "$BINARY_PATH" root@$SERVER:/root/"$BINARY_NAME"

     

       11
       11
       -
       

     

       12
       12
       -
       # SSH into the server and perform the necessary operations

     

       13
       13
       -
       ssh root@$SERVER <<EOF

     

       14
       14
       -
         set -e  # Exit on error

     

       15
       15
       -
       

     

       16
       16
       -
         # Move binary to /usr/local/bin and set executable permissions

     

       17
       17
       -
         mv /root/$BINARY_NAME /usr/local/bin/$BINARY_NAME

     

       18
       18
       -
         chmod +x /usr/local/bin/$BINARY_NAME

     

       19
       19
       -
       

     

       20
       20
       -
         su appview

     

       21
       21
       -
         cd ~

     

       22
       22
       -
         ./reset.sh

     

       23
       23
       -
       EOF

     

       24
       24
       -
       

     

       25
       25
       -
       echo "Deployment complete."

     

       26
       26
       -

-5

scripts/generate-jwks.sh

···

       1
       1
       -
       #! /usr/bin/env bash

     

       2
       2
       -
       

     

       3
       3
       -
       set -e

     

       4
       4
       -
       

     

       5
       5
       -
       go run ./cmd/genjwks/

+31

sets/gen.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"math/rand"

     

       5
       5
       +
       	"reflect"

     

       6
       6
       +
       	"testing/quick"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func (_ Set[T]) Generate(rand *rand.Rand, size int) reflect.Value {

     

       10
       10
       +
       	s := New[T]()

     

       11
       11
       +
       

     

       12
       12
       +
       	var zero T

     

       13
       13
       +
       	itemType := reflect.TypeOf(zero)

     

       14
       14
       +
       

     

       15
       15
       +
       	for {

     

       16
       16
       +
       		if s.Len() >= size {

     

       17
       17
       +
       			break

     

       18
       18
       +
       		}

     

       19
       19
       +
       

     

       20
       20
       +
       		item, ok := quick.Value(itemType, rand)

     

       21
       21
       +
       		if !ok {

     

       22
       22
       +
       			continue

     

       23
       23
       +
       		}

     

       24
       24
       +
       

     

       25
       25
       +
       		if val, ok := item.Interface().(T); ok {

     

       26
       26
       +
       			s.Insert(val)

     

       27
       27
       +
       		}

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	return reflect.ValueOf(s)

     

       31
       31
       +
       }

+35

sets/readme.txt

···

       1
       1
       +
       sets

     

       2
       2
       +
       ----

     

       3
       3
       +
       set datastructure for go with generics and iterators. the

     

       4
       4
       +
       api is supposed to mimic rust's std::collections::HashSet api.

     

       5
       5
       +
       

     

       6
       6
       +
           s1 := sets.Collect(slices.Values([]int{1, 2, 3, 4}))

     

       7
       7
       +
           s2 := sets.Collect(slices.Values([]int{1, 2, 3, 4, 5, 6}))

     

       8
       8
       +
       

     

       9
       9
       +
           union     := sets.Collect(s1.Union(s2))

     

       10
       10
       +
           intersect := sets.Collect(s1.Intersection(s2))

     

       11
       11
       +
           diff      := sets.Collect(s1.Difference(s2))

     

       12
       12
       +
           symdiff   := sets.Collect(s1.SymmetricDifference(s2))

     

       13
       13
       +
       

     

       14
       14
       +
           s1.Len()          // 4

     

       15
       15
       +
           s1.Contains(1)    // true

     

       16
       16
       +
           s1.IsEmpty()      // false

     

       17
       17
       +
           s1.IsSubset(s2)   // true

     

       18
       18
       +
           s1.IsSuperset(s2) // false

     

       19
       19
       +
           s1.IsDisjoint(s2) // false

     

       20
       20
       +
       

     

       21
       21
       +
           if exists := s1.Insert(1); exists {

     

       22
       22
       +
               // already existed in set

     

       23
       23
       +
           }

     

       24
       24
       +
       

     

       25
       25
       +
           if existed := s1.Remove(1); existed {

     

       26
       26
       +
               // existed in set, now removed

     

       27
       27
       +
           }

     

       28
       28
       +
       

     

       29
       29
       +
       

     

       30
       30
       +
       testing

     

       31
       31
       +
       -------

     

       32
       32
       +
       includes property-based tests using the wonderful

     

       33
       33
       +
       testing/quick module!

     

       34
       34
       +
       

     

       35
       35
       +
           go test -v

+174

sets/set.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"iter"

     

       5
       5
       +
       	"maps"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       type Set[T comparable] struct {

     

       9
       9
       +
       	data map[T]struct{}

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       func New[T comparable]() Set[T] {

     

       13
       13
       +
       	return Set[T]{

     

       14
       14
       +
       		data: make(map[T]struct{}),

     

       15
       15
       +
       	}

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       func (s *Set[T]) Insert(item T) bool {

     

       19
       19
       +
       	_, exists := s.data[item]

     

       20
       20
       +
       	s.data[item] = struct{}{}

     

       21
       21
       +
       	return !exists

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       24
       24
       +
       func Singleton[T comparable](item T) Set[T] {

     

       25
       25
       +
       	n := New[T]()

     

       26
       26
       +
       	_ = n.Insert(item)

     

       27
       27
       +
       	return n

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func (s *Set[T]) Remove(item T) bool {

     

       31
       31
       +
       	_, exists := s.data[item]

     

       32
       32
       +
       	if exists {

     

       33
       33
       +
       		delete(s.data, item)

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return exists

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       func (s Set[T]) Contains(item T) bool {

     

       39
       39
       +
       	_, exists := s.data[item]

     

       40
       40
       +
       	return exists

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func (s Set[T]) Len() int {

     

       44
       44
       +
       	return len(s.data)

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       func (s Set[T]) IsEmpty() bool {

     

       48
       48
       +
       	return len(s.data) == 0

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       func (s *Set[T]) Clear() {

     

       52
       52
       +
       	s.data = make(map[T]struct{})

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       func (s Set[T]) All() iter.Seq[T] {

     

       56
       56
       +
       	return func(yield func(T) bool) {

     

       57
       57
       +
       		for item := range s.data {

     

       58
       58
       +
       			if !yield(item) {

     

       59
       59
       +
       				return

     

       60
       60
       +
       			}

     

       61
       61
       +
       		}

     

       62
       62
       +
       	}

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       func (s Set[T]) Clone() Set[T] {

     

       66
       66
       +
       	return Set[T]{

     

       67
       67
       +
       		data: maps.Clone(s.data),

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func (s Set[T]) Union(other Set[T]) iter.Seq[T] {

     

       72
       72
       +
       	if s.Len() >= other.Len() {

     

       73
       73
       +
       		return chain(s.All(), other.Difference(s))

     

       74
       74
       +
       	} else {

     

       75
       75
       +
       		return chain(other.All(), s.Difference(other))

     

       76
       76
       +
       	}

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       func chain[T any](seqs ...iter.Seq[T]) iter.Seq[T] {

     

       80
       80
       +
       	return func(yield func(T) bool) {

     

       81
       81
       +
       		for _, seq := range seqs {

     

       82
       82
       +
       			for item := range seq {

     

       83
       83
       +
       				if !yield(item) {

     

       84
       84
       +
       					return

     

       85
       85
       +
       				}

     

       86
       86
       +
       			}

     

       87
       87
       +
       		}

     

       88
       88
       +
       	}

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       func (s Set[T]) Intersection(other Set[T]) iter.Seq[T] {

     

       92
       92
       +
       	return func(yield func(T) bool) {

     

       93
       93
       +
       		for item := range s.data {

     

       94
       94
       +
       			if other.Contains(item) {

     

       95
       95
       +
       				if !yield(item) {

     

       96
       96
       +
       					return

     

       97
       97
       +
       				}

     

       98
       98
       +
       			}

     

       99
       99
       +
       		}

     

       100
       100
       +
       	}

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       func (s Set[T]) Difference(other Set[T]) iter.Seq[T] {

     

       104
       104
       +
       	return func(yield func(T) bool) {

     

       105
       105
       +
       		for item := range s.data {

     

       106
       106
       +
       			if !other.Contains(item) {

     

       107
       107
       +
       				if !yield(item) {

     

       108
       108
       +
       					return

     

       109
       109
       +
       				}

     

       110
       110
       +
       			}

     

       111
       111
       +
       		}

     

       112
       112
       +
       	}

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       func (s Set[T]) SymmetricDifference(other Set[T]) iter.Seq[T] {

     

       116
       116
       +
       	return func(yield func(T) bool) {

     

       117
       117
       +
       		for item := range s.data {

     

       118
       118
       +
       			if !other.Contains(item) {

     

       119
       119
       +
       				if !yield(item) {

     

       120
       120
       +
       					return

     

       121
       121
       +
       				}

     

       122
       122
       +
       			}

     

       123
       123
       +
       		}

     

       124
       124
       +
       		for item := range other.data {

     

       125
       125
       +
       			if !s.Contains(item) {

     

       126
       126
       +
       				if !yield(item) {

     

       127
       127
       +
       					return

     

       128
       128
       +
       				}

     

       129
       129
       +
       			}

     

       130
       130
       +
       		}

     

       131
       131
       +
       	}

     

       132
       132
       +
       }

     

       133
       133
       +
       

     

       134
       134
       +
       func (s Set[T]) IsSubset(other Set[T]) bool {

     

       135
       135
       +
       	for item := range s.data {

     

       136
       136
       +
       		if !other.Contains(item) {

     

       137
       137
       +
       			return false

     

       138
       138
       +
       		}

     

       139
       139
       +
       	}

     

       140
       140
       +
       	return true

     

       141
       141
       +
       }

     

       142
       142
       +
       

     

       143
       143
       +
       func (s Set[T]) IsSuperset(other Set[T]) bool {

     

       144
       144
       +
       	return other.IsSubset(s)

     

       145
       145
       +
       }

     

       146
       146
       +
       

     

       147
       147
       +
       func (s Set[T]) IsDisjoint(other Set[T]) bool {

     

       148
       148
       +
       	for item := range s.data {

     

       149
       149
       +
       		if other.Contains(item) {

     

       150
       150
       +
       			return false

     

       151
       151
       +
       		}

     

       152
       152
       +
       	}

     

       153
       153
       +
       	return true

     

       154
       154
       +
       }

     

       155
       155
       +
       

     

       156
       156
       +
       func (s Set[T]) Equal(other Set[T]) bool {

     

       157
       157
       +
       	if s.Len() != other.Len() {

     

       158
       158
       +
       		return false

     

       159
       159
       +
       	}

     

       160
       160
       +
       	for item := range s.data {

     

       161
       161
       +
       		if !other.Contains(item) {

     

       162
       162
       +
       			return false

     

       163
       163
       +
       		}

     

       164
       164
       +
       	}

     

       165
       165
       +
       	return true

     

       166
       166
       +
       }

     

       167
       167
       +
       

     

       168
       168
       +
       func Collect[T comparable](seq iter.Seq[T]) Set[T] {

     

       169
       169
       +
       	result := New[T]()

     

       170
       170
       +
       	for item := range seq {

     

       171
       171
       +
       		result.Insert(item)

     

       172
       172
       +
       	}

     

       173
       173
       +
       	return result

     

       174
       174
       +
       }

+411

sets/set_test.go

···

       1
       1
       +
       package sets

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"slices"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       	"testing/quick"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func TestNew(t *testing.T) {

     

       10
       10
       +
       	s := New[int]()

     

       11
       11
       +
       	if s.Len() != 0 {

     

       12
       12
       +
       		t.Errorf("New set should be empty, got length %d", s.Len())

     

       13
       13
       +
       	}

     

       14
       14
       +
       	if !s.IsEmpty() {

     

       15
       15
       +
       		t.Error("New set should be empty")

     

       16
       16
       +
       	}

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       func TestFromSlice(t *testing.T) {

     

       20
       20
       +
       	s := Collect(slices.Values([]int{1, 2, 3, 2, 1}))

     

       21
       21
       +
       	if s.Len() != 3 {

     

       22
       22
       +
       		t.Errorf("Expected length 3, got %d", s.Len())

     

       23
       23
       +
       	}

     

       24
       24
       +
       	if !s.Contains(1) || !s.Contains(2) || !s.Contains(3) {

     

       25
       25
       +
       		t.Error("Set should contain all unique elements from slice")

     

       26
       26
       +
       	}

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func TestInsert(t *testing.T) {

     

       30
       30
       +
       	s := New[string]()

     

       31
       31
       +
       

     

       32
       32
       +
       	if !s.Insert("hello") {

     

       33
       33
       +
       		t.Error("First insert should return true")

     

       34
       34
       +
       	}

     

       35
       35
       +
       	if s.Insert("hello") {

     

       36
       36
       +
       		t.Error("Duplicate insert should return false")

     

       37
       37
       +
       	}

     

       38
       38
       +
       	if s.Len() != 1 {

     

       39
       39
       +
       		t.Errorf("Expected length 1, got %d", s.Len())

     

       40
       40
       +
       	}

     

       41
       41
       +
       }

     

       42
       42
       +
       

     

       43
       43
       +
       func TestRemove(t *testing.T) {

     

       44
       44
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       45
       45
       +
       

     

       46
       46
       +
       	if !s.Remove(2) {

     

       47
       47
       +
       		t.Error("Remove existing element should return true")

     

       48
       48
       +
       	}

     

       49
       49
       +
       	if s.Remove(2) {

     

       50
       50
       +
       		t.Error("Remove non-existing element should return false")

     

       51
       51
       +
       	}

     

       52
       52
       +
       	if s.Contains(2) {

     

       53
       53
       +
       		t.Error("Element should be removed")

     

       54
       54
       +
       	}

     

       55
       55
       +
       	if s.Len() != 2 {

     

       56
       56
       +
       		t.Errorf("Expected length 2, got %d", s.Len())

     

       57
       57
       +
       	}

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       func TestContains(t *testing.T) {

     

       61
       61
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       62
       62
       +
       

     

       63
       63
       +
       	if !s.Contains(1) {

     

       64
       64
       +
       		t.Error("Should contain 1")

     

       65
       65
       +
       	}

     

       66
       66
       +
       	if s.Contains(4) {

     

       67
       67
       +
       		t.Error("Should not contain 4")

     

       68
       68
       +
       	}

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func TestClear(t *testing.T) {

     

       72
       72
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       73
       73
       +
       	s.Clear()

     

       74
       74
       +
       

     

       75
       75
       +
       	if !s.IsEmpty() {

     

       76
       76
       +
       		t.Error("Set should be empty after clear")

     

       77
       77
       +
       	}

     

       78
       78
       +
       	if s.Len() != 0 {

     

       79
       79
       +
       		t.Errorf("Expected length 0, got %d", s.Len())

     

       80
       80
       +
       	}

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       func TestIterator(t *testing.T) {

     

       84
       84
       +
       	s := Collect(slices.Values([]int{1, 2, 3}))

     

       85
       85
       +
       	var items []int

     

       86
       86
       +
       

     

       87
       87
       +
       	for item := range s.All() {

     

       88
       88
       +
       		items = append(items, item)

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	slices.Sort(items)

     

       92
       92
       +
       	expected := []int{1, 2, 3}

     

       93
       93
       +
       	if !slices.Equal(items, expected) {

     

       94
       94
       +
       		t.Errorf("Expected %v, got %v", expected, items)

     

       95
       95
       +
       	}

     

       96
       96
       +
       }

     

       97
       97
       +
       

     

       98
       98
       +
       func TestClone(t *testing.T) {

     

       99
       99
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       100
       100
       +
       	s2 := s1.Clone()

     

       101
       101
       +
       

     

       102
       102
       +
       	if !s1.Equal(s2) {

     

       103
       103
       +
       		t.Error("Cloned set should be equal to original")

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	s2.Insert(4)

     

       107
       107
       +
       	if s1.Contains(4) {

     

       108
       108
       +
       		t.Error("Modifying clone should not affect original")

     

       109
       109
       +
       	}

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       func TestUnion(t *testing.T) {

     

       113
       113
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       114
       114
       +
       	s2 := Collect(slices.Values([]int{2, 3}))

     

       115
       115
       +
       

     

       116
       116
       +
       	result := Collect(s1.Union(s2))

     

       117
       117
       +
       	expected := Collect(slices.Values([]int{1, 2, 3}))

     

       118
       118
       +
       

     

       119
       119
       +
       	if !result.Equal(expected) {

     

       120
       120
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       121
       121
       +
       	}

     

       122
       122
       +
       }

     

       123
       123
       +
       

     

       124
       124
       +
       func TestIntersection(t *testing.T) {

     

       125
       125
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       126
       126
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       127
       127
       +
       

     

       128
       128
       +
       	expected := Collect(slices.Values([]int{2, 3}))

     

       129
       129
       +
       	result := Collect(s1.Intersection(s2))

     

       130
       130
       +
       

     

       131
       131
       +
       	if !result.Equal(expected) {

     

       132
       132
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       133
       133
       +
       	}

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       func TestDifference(t *testing.T) {

     

       137
       137
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       138
       138
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       139
       139
       +
       

     

       140
       140
       +
       	expected := Collect(slices.Values([]int{1}))

     

       141
       141
       +
       	result := Collect(s1.Difference(s2))

     

       142
       142
       +
       

     

       143
       143
       +
       	if !result.Equal(expected) {

     

       144
       144
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       145
       145
       +
       	}

     

       146
       146
       +
       }

     

       147
       147
       +
       

     

       148
       148
       +
       func TestSymmetricDifference(t *testing.T) {

     

       149
       149
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       150
       150
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       151
       151
       +
       

     

       152
       152
       +
       	expected := Collect(slices.Values([]int{1, 4}))

     

       153
       153
       +
       	result := Collect(s1.SymmetricDifference(s2))

     

       154
       154
       +
       

     

       155
       155
       +
       	if !result.Equal(expected) {

     

       156
       156
       +
       		t.Errorf("Expected %v, got %v", expected, result)

     

       157
       157
       +
       	}

     

       158
       158
       +
       }

     

       159
       159
       +
       

     

       160
       160
       +
       func TestSymmetricDifferenceCommutativeProperty(t *testing.T) {

     

       161
       161
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       162
       162
       +
       	s2 := Collect(slices.Values([]int{2, 3, 4}))

     

       163
       163
       +
       

     

       164
       164
       +
       	result1 := Collect(s1.SymmetricDifference(s2))

     

       165
       165
       +
       	result2 := Collect(s2.SymmetricDifference(s1))

     

       166
       166
       +
       

     

       167
       167
       +
       	if !result1.Equal(result2) {

     

       168
       168
       +
       		t.Errorf("Expected %v, got %v", result1, result2)

     

       169
       169
       +
       	}

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       func TestIsSubset(t *testing.T) {

     

       173
       173
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       174
       174
       +
       	s2 := Collect(slices.Values([]int{1, 2, 3}))

     

       175
       175
       +
       

     

       176
       176
       +
       	if !s1.IsSubset(s2) {

     

       177
       177
       +
       		t.Error("s1 should be subset of s2")

     

       178
       178
       +
       	}

     

       179
       179
       +
       	if s2.IsSubset(s1) {

     

       180
       180
       +
       		t.Error("s2 should not be subset of s1")

     

       181
       181
       +
       	}

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       func TestIsSuperset(t *testing.T) {

     

       185
       185
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       186
       186
       +
       	s2 := Collect(slices.Values([]int{1, 2}))

     

       187
       187
       +
       

     

       188
       188
       +
       	if !s1.IsSuperset(s2) {

     

       189
       189
       +
       		t.Error("s1 should be superset of s2")

     

       190
       190
       +
       	}

     

       191
       191
       +
       	if s2.IsSuperset(s1) {

     

       192
       192
       +
       		t.Error("s2 should not be superset of s1")

     

       193
       193
       +
       	}

     

       194
       194
       +
       }

     

       195
       195
       +
       

     

       196
       196
       +
       func TestIsDisjoint(t *testing.T) {

     

       197
       197
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       198
       198
       +
       	s2 := Collect(slices.Values([]int{3, 4}))

     

       199
       199
       +
       	s3 := Collect(slices.Values([]int{2, 3}))

     

       200
       200
       +
       

     

       201
       201
       +
       	if !s1.IsDisjoint(s2) {

     

       202
       202
       +
       		t.Error("s1 and s2 should be disjoint")

     

       203
       203
       +
       	}

     

       204
       204
       +
       	if s1.IsDisjoint(s3) {

     

       205
       205
       +
       		t.Error("s1 and s3 should not be disjoint")

     

       206
       206
       +
       	}

     

       207
       207
       +
       }

     

       208
       208
       +
       

     

       209
       209
       +
       func TestEqual(t *testing.T) {

     

       210
       210
       +
       	s1 := Collect(slices.Values([]int{1, 2, 3}))

     

       211
       211
       +
       	s2 := Collect(slices.Values([]int{3, 2, 1}))

     

       212
       212
       +
       	s3 := Collect(slices.Values([]int{1, 2}))

     

       213
       213
       +
       

     

       214
       214
       +
       	if !s1.Equal(s2) {

     

       215
       215
       +
       		t.Error("s1 and s2 should be equal")

     

       216
       216
       +
       	}

     

       217
       217
       +
       	if s1.Equal(s3) {

     

       218
       218
       +
       		t.Error("s1 and s3 should not be equal")

     

       219
       219
       +
       	}

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func TestCollect(t *testing.T) {

     

       223
       223
       +
       	s1 := Collect(slices.Values([]int{1, 2}))

     

       224
       224
       +
       	s2 := Collect(slices.Values([]int{2, 3}))

     

       225
       225
       +
       

     

       226
       226
       +
       	unionSet := Collect(s1.Union(s2))

     

       227
       227
       +
       	if unionSet.Len() != 3 {

     

       228
       228
       +
       		t.Errorf("Expected union set length 3, got %d", unionSet.Len())

     

       229
       229
       +
       	}

     

       230
       230
       +
       	if !unionSet.Contains(1) || !unionSet.Contains(2) || !unionSet.Contains(3) {

     

       231
       231
       +
       		t.Error("Union set should contain 1, 2, and 3")

     

       232
       232
       +
       	}

     

       233
       233
       +
       

     

       234
       234
       +
       	diffSet := Collect(s1.Difference(s2))

     

       235
       235
       +
       	if diffSet.Len() != 1 {

     

       236
       236
       +
       		t.Errorf("Expected difference set length 1, got %d", diffSet.Len())

     

       237
       237
       +
       	}

     

       238
       238
       +
       	if !diffSet.Contains(1) {

     

       239
       239
       +
       		t.Error("Difference set should contain 1")

     

       240
       240
       +
       	}

     

       241
       241
       +
       }

     

       242
       242
       +
       

     

       243
       243
       +
       func TestPropertySingleonLen(t *testing.T) {

     

       244
       244
       +
       	f := func(item int) bool {

     

       245
       245
       +
       		single := Singleton(item)

     

       246
       246
       +
       		return single.Len() == 1

     

       247
       247
       +
       	}

     

       248
       248
       +
       

     

       249
       249
       +
       	if err := quick.Check(f, nil); err != nil {

     

       250
       250
       +
       		t.Error(err)

     

       251
       251
       +
       	}

     

       252
       252
       +
       }

     

       253
       253
       +
       

     

       254
       254
       +
       func TestPropertyInsertIdempotent(t *testing.T) {

     

       255
       255
       +
       	f := func(s Set[int], item int) bool {

     

       256
       256
       +
       		clone := s.Clone()

     

       257
       257
       +
       

     

       258
       258
       +
       		clone.Insert(item)

     

       259
       259
       +
       		firstLen := clone.Len()

     

       260
       260
       +
       

     

       261
       261
       +
       		clone.Insert(item)

     

       262
       262
       +
       		secondLen := clone.Len()

     

       263
       263
       +
       

     

       264
       264
       +
       		return firstLen == secondLen

     

       265
       265
       +
       	}

     

       266
       266
       +
       

     

       267
       267
       +
       	if err := quick.Check(f, nil); err != nil {

     

       268
       268
       +
       		t.Error(err)

     

       269
       269
       +
       	}

     

       270
       270
       +
       }

     

       271
       271
       +
       

     

       272
       272
       +
       func TestPropertyUnionCommutative(t *testing.T) {

     

       273
       273
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       274
       274
       +
       		union1 := Collect(s1.Union(s2))

     

       275
       275
       +
       		union2 := Collect(s2.Union(s1))

     

       276
       276
       +
       		return union1.Equal(union2)

     

       277
       277
       +
       	}

     

       278
       278
       +
       

     

       279
       279
       +
       	if err := quick.Check(f, nil); err != nil {

     

       280
       280
       +
       		t.Error(err)

     

       281
       281
       +
       	}

     

       282
       282
       +
       }

     

       283
       283
       +
       

     

       284
       284
       +
       func TestPropertyIntersectionCommutative(t *testing.T) {

     

       285
       285
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       286
       286
       +
       		inter1 := Collect(s1.Intersection(s2))

     

       287
       287
       +
       		inter2 := Collect(s2.Intersection(s1))

     

       288
       288
       +
       		return inter1.Equal(inter2)

     

       289
       289
       +
       	}

     

       290
       290
       +
       

     

       291
       291
       +
       	if err := quick.Check(f, nil); err != nil {

     

       292
       292
       +
       		t.Error(err)

     

       293
       293
       +
       	}

     

       294
       294
       +
       }

     

       295
       295
       +
       

     

       296
       296
       +
       func TestPropertyCloneEquals(t *testing.T) {

     

       297
       297
       +
       	f := func(s Set[int]) bool {

     

       298
       298
       +
       		clone := s.Clone()

     

       299
       299
       +
       		return s.Equal(clone)

     

       300
       300
       +
       	}

     

       301
       301
       +
       

     

       302
       302
       +
       	if err := quick.Check(f, nil); err != nil {

     

       303
       303
       +
       		t.Error(err)

     

       304
       304
       +
       	}

     

       305
       305
       +
       }

     

       306
       306
       +
       

     

       307
       307
       +
       func TestPropertyIntersectionIsSubset(t *testing.T) {

     

       308
       308
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       309
       309
       +
       		inter := Collect(s1.Intersection(s2))

     

       310
       310
       +
       		return inter.IsSubset(s1) && inter.IsSubset(s2)

     

       311
       311
       +
       	}

     

       312
       312
       +
       

     

       313
       313
       +
       	if err := quick.Check(f, nil); err != nil {

     

       314
       314
       +
       		t.Error(err)

     

       315
       315
       +
       	}

     

       316
       316
       +
       }

     

       317
       317
       +
       

     

       318
       318
       +
       func TestPropertyUnionIsSuperset(t *testing.T) {

     

       319
       319
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       320
       320
       +
       		union := Collect(s1.Union(s2))

     

       321
       321
       +
       		return union.IsSuperset(s1) && union.IsSuperset(s2)

     

       322
       322
       +
       	}

     

       323
       323
       +
       

     

       324
       324
       +
       	if err := quick.Check(f, nil); err != nil {

     

       325
       325
       +
       		t.Error(err)

     

       326
       326
       +
       	}

     

       327
       327
       +
       }

     

       328
       328
       +
       

     

       329
       329
       +
       func TestPropertyDifferenceDisjoint(t *testing.T) {

     

       330
       330
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       331
       331
       +
       		diff := Collect(s1.Difference(s2))

     

       332
       332
       +
       		return diff.IsDisjoint(s2)

     

       333
       333
       +
       	}

     

       334
       334
       +
       

     

       335
       335
       +
       	if err := quick.Check(f, nil); err != nil {

     

       336
       336
       +
       		t.Error(err)

     

       337
       337
       +
       	}

     

       338
       338
       +
       }

     

       339
       339
       +
       

     

       340
       340
       +
       func TestPropertySymmetricDifferenceCommutative(t *testing.T) {

     

       341
       341
       +
       	f := func(s1 Set[int], s2 Set[int]) bool {

     

       342
       342
       +
       		symDiff1 := Collect(s1.SymmetricDifference(s2))

     

       343
       343
       +
       		symDiff2 := Collect(s2.SymmetricDifference(s1))

     

       344
       344
       +
       		return symDiff1.Equal(symDiff2)

     

       345
       345
       +
       	}

     

       346
       346
       +
       

     

       347
       347
       +
       	if err := quick.Check(f, nil); err != nil {

     

       348
       348
       +
       		t.Error(err)

     

       349
       349
       +
       	}

     

       350
       350
       +
       }

     

       351
       351
       +
       

     

       352
       352
       +
       func TestPropertyRemoveWorks(t *testing.T) {

     

       353
       353
       +
       	f := func(s Set[int], item int) bool {

     

       354
       354
       +
       		clone := s.Clone()

     

       355
       355
       +
       		clone.Insert(item)

     

       356
       356
       +
       		clone.Remove(item)

     

       357
       357
       +
       		return !clone.Contains(item)

     

       358
       358
       +
       	}

     

       359
       359
       +
       

     

       360
       360
       +
       	if err := quick.Check(f, nil); err != nil {

     

       361
       361
       +
       		t.Error(err)

     

       362
       362
       +
       	}

     

       363
       363
       +
       }

     

       364
       364
       +
       

     

       365
       365
       +
       func TestPropertyClearEmpty(t *testing.T) {

     

       366
       366
       +
       	f := func(s Set[int]) bool {

     

       367
       367
       +
       		s.Clear()

     

       368
       368
       +
       		return s.IsEmpty() && s.Len() == 0

     

       369
       369
       +
       	}

     

       370
       370
       +
       

     

       371
       371
       +
       	if err := quick.Check(f, nil); err != nil {

     

       372
       372
       +
       		t.Error(err)

     

       373
       373
       +
       	}

     

       374
       374
       +
       }

     

       375
       375
       +
       

     

       376
       376
       +
       func TestPropertyIsSubsetReflexive(t *testing.T) {

     

       377
       377
       +
       	f := func(s Set[int]) bool {

     

       378
       378
       +
       		return s.IsSubset(s)

     

       379
       379
       +
       	}

     

       380
       380
       +
       

     

       381
       381
       +
       	if err := quick.Check(f, nil); err != nil {

     

       382
       382
       +
       		t.Error(err)

     

       383
       383
       +
       	}

     

       384
       384
       +
       }

     

       385
       385
       +
       

     

       386
       386
       +
       func TestPropertyDeMorganUnion(t *testing.T) {

     

       387
       387
       +
       	f := func(s1 Set[int], s2 Set[int], universe Set[int]) bool {

     

       388
       388
       +
       		// create a universe that contains both sets

     

       389
       389
       +
       		u := universe.Clone()

     

       390
       390
       +
       		for item := range s1.All() {

     

       391
       391
       +
       			u.Insert(item)

     

       392
       392
       +
       		}

     

       393
       393
       +
       		for item := range s2.All() {

     

       394
       394
       +
       			u.Insert(item)

     

       395
       395
       +
       		}

     

       396
       396
       +
       

     

       397
       397
       +
       		// (A u B)' = A' n B'

     

       398
       398
       +
       		union := Collect(s1.Union(s2))

     

       399
       399
       +
       		complementUnion := Collect(u.Difference(union))

     

       400
       400
       +
       

     

       401
       401
       +
       		complementS1 := Collect(u.Difference(s1))

     

       402
       402
       +
       		complementS2 := Collect(u.Difference(s2))

     

       403
       403
       +
       		intersectionComplements := Collect(complementS1.Intersection(complementS2))

     

       404
       404
       +
       

     

       405
       405
       +
       		return complementUnion.Equal(intersectionComplements)

     

       406
       406
       +
       	}

     

       407
       407
       +
       

     

       408
       408
       +
       	if err := quick.Check(f, nil); err != nil {

     

       409
       409
       +
       		t.Error(err)

     

       410
       410
       +
       	}

     

       411
       411
       +
       }

spindle/config/config.go

···

       13
       13
        
       	DBPath            string  `env:"DB_PATH, default=spindle.db"`

     

       14
       14
        
       	Hostname          string  `env:"HOSTNAME, required"`

     

       15
       15
        
       	JetstreamEndpoint string  `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       16
       16
       +
       	PlcUrl            string  `env:"PLC_URL, default=https://plc.directory"`

     

       16
       17
        
       	Dev               bool    `env:"DEV, default=false"`

     

       17
       18
        
       	Owner             string  `env:"OWNER, required"`

     

       18
       19
        
       	Secrets           Secrets `env:",prefix=SECRETS_"`

+13 -3

spindle/engine/engine.go

···

       79
       79
        
       				defer cancel()

     

       80
       80
        
       

     

       81
       81
        
       				for stepIdx, step := range w.Steps {

     

       82
       82
       +
       					// log start of step

     

       82
       83
        
       					if wfLogger != nil {

     

       83
       83
       -
       						ctl := wfLogger.ControlWriter(stepIdx, step)

     

       84
       84
       -
       						ctl.Write([]byte(step.Name()))

     

       84
       84
       +
       						wfLogger.

     

       85
       85
       +
       							ControlWriter(stepIdx, step, models.StepStatusStart).

     

       86
       86
       +
       							Write([]byte{0})

     

       85
       87
        
       					}

     

       86
       88
        
       

     

       87
       89
        
       					err = eng.RunStep(ctx, wid, &w, stepIdx, allSecrets, wfLogger)

     

       90
       90
       +
       

     

       91
       91
       +
       					// log end of step

     

       92
       92
       +
       					if wfLogger != nil {

     

       93
       93
       +
       						wfLogger.

     

       94
       94
       +
       							ControlWriter(stepIdx, step, models.StepStatusEnd).

     

       95
       95
       +
       							Write([]byte{0})

     

       96
       96
       +
       					}

     

       97
       97
       +
       

     

       88
       98
        
       					if err != nil {

     

       89
       99
        
       						if errors.Is(err, ErrTimedOut) {

     

       90
       100
        
       							dbErr := db.StatusTimeout(wid, n)

     
···

       115
       125
        
       	if err := eg.Wait(); err != nil {

     

       116
       126
        
       		l.Error("failed to run one or more workflows", "err", err)

     

       117
       127
        
       	} else {

     

       118
       118
       -
       		l.Error("successfully ran full pipeline")

     

       128
       128
       +
       		l.Info("successfully ran full pipeline")

     

       119
       129
        
       	}

     

       120
       130
        
       }

+13 -12

spindle/engines/nixery/engine.go

···

       73
       73
        
       type addlFields struct {

     

       74
       74
        
       	image     string

     

       75
       75
        
       	container string

     

       76
       76
       -
       	env       map[string]string

     

       77
       76
        
       }

     

       78
       77
        
       

     

       79
       78
        
       func (e *Engine) InitWorkflow(twf tangled.Pipeline_Workflow, tpl tangled.Pipeline) (*models.Workflow, error) {

     
···

       103
       102
        
       		swf.Steps = append(swf.Steps, sstep)

     

       104
       103
        
       	}

     

       105
       104
        
       	swf.Name = twf.Name

     

       106
       106
       -
       	addl.env = dwf.Environment

     

       105
       105
       +
       	swf.Environment = dwf.Environment

     

       107
       106
        
       	addl.image = workflowImage(dwf.Dependencies, e.cfg.NixeryPipelines.Nixery)

     

       108
       107
        
       

     

       109
       108
        
       	setup := &setupSteps{}

     

       110
       109
        
       

     

       111
       110
        
       	setup.addStep(nixConfStep())

     

       112
       112
       -
       	setup.addStep(cloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev))

     

       111
       111
       +
       	setup.addStep(models.BuildCloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev))

     

       113
       112
        
       	// this step could be empty

     

       114
       113
        
       	if s := dependencyStep(dwf.Dependencies); s != nil {

     

       115
       114
        
       		setup.addStep(*s)

     
···

       222
       221
        
       		},

     

       223
       222
        
       		ReadonlyRootfs: false,

     

       224
       223
        
       		CapDrop:        []string{"ALL"},

     

       225
       225
       -
       		CapAdd:         []string{"CAP_DAC_OVERRIDE"},

     

       224
       224
       +
       		CapAdd:         []string{"CAP_DAC_OVERRIDE", "CAP_CHOWN", "CAP_FOWNER", "CAP_SETUID", "CAP_SETGID"},

     

       226
       225
        
       		SecurityOpt:    []string{"no-new-privileges"},

     

       227
       226
        
       		ExtraHosts:     []string{"host.docker.internal:host-gateway"},

     

       228
       227
        
       	}, nil, nil, "")

     
···

       288
       287
        
       

     

       289
       288
        
       func (e *Engine) RunStep(ctx context.Context, wid models.WorkflowId, w *models.Workflow, idx int, secrets []secrets.UnlockedSecret, wfLogger *models.WorkflowLogger) error {

     

       290
       289
        
       	addl := w.Data.(addlFields)

     

       291
       291
       -
       	workflowEnvs := ConstructEnvs(addl.env)

     

       290
       290
       +
       	workflowEnvs := ConstructEnvs(w.Environment)

     

       292
       291
        
       	// TODO(winter): should SetupWorkflow also have secret access?

     

       293
       292
        
       	// IMO yes, but probably worth thinking on.

     

       294
       293
        
       	for _, s := range secrets {

     

       295
       294
        
       		workflowEnvs.AddEnv(s.Key, s.Value)

     

       296
       295
        
       	}

     

       297
       296
        
       

     

       298
       298
       -
       	step := w.Steps[idx].(Step)

     

       297
       297
       +
       	step := w.Steps[idx]

     

       299
       298
        
       

     

       300
       299
        
       	select {

     

       301
       300
        
       	case <-ctx.Done():

     
···

       304
       303
        
       	}

     

       305
       304
        
       

     

       306
       305
        
       	envs := append(EnvVars(nil), workflowEnvs...)

     

       307
       307
       -
       	for k, v := range step.environment {

     

       308
       308
       -
       		envs.AddEnv(k, v)

     

       306
       306
       +
       	if nixStep, ok := step.(Step); ok {

     

       307
       307
       +
       		for k, v := range nixStep.environment {

     

       308
       308
       +
       			envs.AddEnv(k, v)

     

       309
       309
       +
       		}

     

       309
       310
        
       	}

     

       310
       311
        
       	envs.AddEnv("HOME", homeDir)

     

       311
       312
        
       

     

       312
       313
        
       	mkExecResp, err := e.docker.ContainerExecCreate(ctx, addl.container, container.ExecOptions{

     

       313
       313
       -
       		Cmd:          []string{"bash", "-c", step.command},

     

       314
       314
       +
       		Cmd:          []string{"bash", "-c", step.Command()},

     

       314
       315
        
       		AttachStdout: true,

     

       315
       316
        
       		AttachStderr: true,

     

       316
       317
        
       		Env:          envs,

     
···

       333
       334
        
       		// Docker doesn't provide an API to kill an exec run

     

       334
       335
        
       		// (sure, we could grab the PID and kill it ourselves,

     

       335
       336
        
       		// but that's wasted effort)

     

       336
       336
       -
       		e.l.Warn("step timed out", "step", step.Name)

     

       337
       337
       +
       		e.l.Warn("step timed out", "step", step.Name())

     

       337
       338
        
       

     

       338
       339
        
       		<-tailDone

     

       339
       340
        
       

     
···

       381
       382
        
       	defer logs.Close()

     

       382
       383
        
       

     

       383
       384
        
       	_, err = stdcopy.StdCopy(

     

       384
       384
       -
       		wfLogger.DataWriter("stdout"),

     

       385
       385
       -
       		wfLogger.DataWriter("stderr"),

     

       385
       385
       +
       		wfLogger.DataWriter(stepIdx, "stdout"),

     

       386
       386
       +
       		wfLogger.DataWriter(stepIdx, "stderr"),

     

       386
       387
        
       		logs.Reader,

     

       387
       388
        
       	)

     

       388
       389
        
       	if err != nil && err != io.EOF && !errors.Is(err, context.DeadlineExceeded) {

-73

spindle/engines/nixery/setup_steps.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
       -
       	"path"

     

       6
       5
        
       	"strings"

     

       7
       7
       -
       

     

       8
       8
       -
       	"tangled.org/core/api/tangled"

     

       9
       9
       -
       	"tangled.org/core/workflow"

     

       10
       6
        
       )

     

       11
       7
        
       

     

       12
       8
        
       func nixConfStep() Step {

     
···

       17
       13
        
       		command: setupCmd,

     

       18
       14
        
       		name:    "Configure Nix",

     

       19
       15
        
       	}

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       // cloneOptsAsSteps processes clone options and adds corresponding steps

     

       23
       23
       -
       // to the beginning of the workflow's step list if cloning is not skipped.

     

       24
       24
       -
       //

     

       25
       25
       -
       // the steps to do here are:

     

       26
       26
       -
       // - git init

     

       27
       27
       -
       // - git remote add origin <url>

     

       28
       28
       -
       // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>

     

       29
       29
       -
       // - git checkout FETCH_HEAD

     

       30
       30
       -
       func cloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) Step {

     

       31
       31
       -
       	if twf.Clone.Skip {

     

       32
       32
       -
       		return Step{}

     

       33
       33
       -
       	}

     

       34
       34
       -
       

     

       35
       35
       -
       	var commands []string

     

       36
       36
       -
       

     

       37
       37
       -
       	// initialize git repo in workspace

     

       38
       38
       -
       	commands = append(commands, "git init")

     

       39
       39
       -
       

     

       40
       40
       -
       	// add repo as git remote

     

       41
       41
       -
       	scheme := "https://"

     

       42
       42
       -
       	if dev {

     

       43
       43
       -
       		scheme = "http://"

     

       44
       44
       -
       		tr.Repo.Knot = strings.ReplaceAll(tr.Repo.Knot, "localhost", "host.docker.internal")

     

       45
       45
       -
       	}

     

       46
       46
       -
       	url := scheme + path.Join(tr.Repo.Knot, tr.Repo.Did, tr.Repo.Repo)

     

       47
       47
       -
       	commands = append(commands, fmt.Sprintf("git remote add origin %s", url))

     

       48
       48
       -
       

     

       49
       49
       -
       	// run git fetch

     

       50
       50
       -
       	{

     

       51
       51
       -
       		var fetchArgs []string

     

       52
       52
       -
       

     

       53
       53
       -
       		// default clone depth is 1

     

       54
       54
       -
       		depth := 1

     

       55
       55
       -
       		if twf.Clone.Depth > 1 {

     

       56
       56
       -
       			depth = int(twf.Clone.Depth)

     

       57
       57
       -
       		}

     

       58
       58
       -
       		fetchArgs = append(fetchArgs, fmt.Sprintf("--depth=%d", depth))

     

       59
       59
       -
       

     

       60
       60
       -
       		// optionally recurse submodules

     

       61
       61
       -
       		if twf.Clone.Submodules {

     

       62
       62
       -
       			fetchArgs = append(fetchArgs, "--recurse-submodules=yes")

     

       63
       63
       -
       		}

     

       64
       64
       -
       

     

       65
       65
       -
       		// set remote to fetch from

     

       66
       66
       -
       		fetchArgs = append(fetchArgs, "origin")

     

       67
       67
       -
       

     

       68
       68
       -
       		// set revision to checkout

     

       69
       69
       -
       		switch workflow.TriggerKind(tr.Kind) {

     

       70
       70
       -
       		case workflow.TriggerKindManual:

     

       71
       71
       -
       			// TODO: unimplemented

     

       72
       72
       -
       		case workflow.TriggerKindPush:

     

       73
       73
       -
       			fetchArgs = append(fetchArgs, tr.Push.NewSha)

     

       74
       74
       -
       		case workflow.TriggerKindPullRequest:

     

       75
       75
       -
       			fetchArgs = append(fetchArgs, tr.PullRequest.SourceSha)

     

       76
       76
       -
       		}

     

       77
       77
       -
       

     

       78
       78
       -
       		commands = append(commands, fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")))

     

       79
       79
       -
       	}

     

       80
       80
       -
       

     

       81
       81
       -
       	// run git checkout

     

       82
       82
       -
       	commands = append(commands, "git checkout FETCH_HEAD")

     

       83
       83
       -
       

     

       84
       84
       -
       	cloneStep := Step{

     

       85
       85
       -
       		command: strings.Join(commands, "\n"),

     

       86
       86
       -
       		name:    "Clone repository into workspace",

     

       87
       87
       -
       	}

     

       88
       88
       -
       	return cloneStep

     

       89
       16
        
       }

     

       90
       17
        
       

     

       91
       18
        
       // dependencyStep processes dependencies defined in the workflow.

+3 -7

spindle/ingester.go

···

       9
       9
        
       

     

       10
       10
        
       	"tangled.org/core/api/tangled"

     

       11
       11
        
       	"tangled.org/core/eventconsumer"

     

       12
       12
       -
       	"tangled.org/core/idresolver"

     

       13
       12
        
       	"tangled.org/core/rbac"

     

       14
       13
        
       	"tangled.org/core/spindle/db"

     

       15
       14
        
       

     
···

       142
       141
        
       func (s *Spindle) ingestRepo(ctx context.Context, e *models.Event) error {

     

       143
       142
        
       	var err error

     

       144
       143
        
       	did := e.Did

     

       145
       145
       -
       	resolver := idresolver.DefaultResolver()

     

       146
       144
        
       

     

       147
       145
        
       	l := s.l.With("component", "ingester", "record", tangled.RepoNSID)

     

       148
       146
        
       

     
···

       190
       188
        
       		}

     

       191
       189
        
       

     

       192
       190
        
       		// add collaborators to rbac

     

       193
       193
       -
       		owner, err := resolver.ResolveIdent(ctx, did)

     

       191
       191
       +
       		owner, err := s.res.ResolveIdent(ctx, did)

     

       194
       192
        
       		if err != nil || owner.Handle.IsInvalidHandle() {

     

       195
       193
        
       			return err

     

       196
       194
        
       		}

     
···

       225
       223
        
       			return err

     

       226
       224
        
       		}

     

       227
       225
        
       

     

       228
       228
       -
       		resolver := idresolver.DefaultResolver()

     

       229
       229
       -
       

     

       230
       230
       -
       		subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       226
       226
       +
       		subjectId, err := s.res.ResolveIdent(ctx, record.Subject)

     

       231
       227
        
       		if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       232
       228
        
       			return err

     

       233
       229
        
       		}

     
···

       240
       236
        
       

     

       241
       237
        
       		// TODO: get rid of this entirely

     

       242
       238
        
       		// resolve this aturi to extract the repo record

     

       243
       243
       -
       		owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       239
       239
       +
       		owner, err := s.res.ResolveIdent(ctx, repoAt.Authority().String())

     

       244
       240
        
       		if err != nil || owner.Handle.IsInvalidHandle() {

     

       245
       241
        
       			return fmt.Errorf("failed to resolve handle: %w", err)

     

       246
       242
        
       		}

+150

spindle/models/clone.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"strings"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       type CloneStep struct {

     

       12
       12
       +
       	name     string

     

       13
       13
       +
       	kind     StepKind

     

       14
       14
       +
       	commands []string

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       func (s CloneStep) Name() string {

     

       18
       18
       +
       	return s.name

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func (s CloneStep) Commands() []string {

     

       22
       22
       +
       	return s.commands

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       func (s CloneStep) Command() string {

     

       26
       26
       +
       	return strings.Join(s.commands, "\n")

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func (s CloneStep) Kind() StepKind {

     

       30
       30
       +
       	return s.kind

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // BuildCloneStep generates git clone commands.

     

       34
       34
       +
       // The caller must ensure the current working directory is set to the desired

     

       35
       35
       +
       // workspace directory before executing these commands.

     

       36
       36
       +
       //

     

       37
       37
       +
       // The generated commands are:

     

       38
       38
       +
       // - git init

     

       39
       39
       +
       // - git remote add origin <url>

     

       40
       40
       +
       // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha>

     

       41
       41
       +
       // - git checkout FETCH_HEAD

     

       42
       42
       +
       //

     

       43
       43
       +
       // Supports all trigger types (push, PR, manual) and clone options.

     

       44
       44
       +
       func BuildCloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) CloneStep {

     

       45
       45
       +
       	if twf.Clone != nil && twf.Clone.Skip {

     

       46
       46
       +
       		return CloneStep{}

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	commitSHA, err := extractCommitSHA(tr)

     

       50
       50
       +
       	if err != nil {

     

       51
       51
       +
       		return CloneStep{

     

       52
       52
       +
       			kind:     StepKindSystem,

     

       53
       53
       +
       			name:     "Clone repository into workspace (error)",

     

       54
       54
       +
       			commands: []string{fmt.Sprintf("echo 'Failed to get clone info: %s' && exit 1", err.Error())},

     

       55
       55
       +
       		}

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	repoURL := BuildRepoURL(tr.Repo, dev)

     

       59
       59
       +
       

     

       60
       60
       +
       	var cloneOpts tangled.Pipeline_CloneOpts

     

       61
       61
       +
       	if twf.Clone != nil {

     

       62
       62
       +
       		cloneOpts = *twf.Clone

     

       63
       63
       +
       	}

     

       64
       64
       +
       	fetchArgs := buildFetchArgs(cloneOpts, commitSHA)

     

       65
       65
       +
       

     

       66
       66
       +
       	return CloneStep{

     

       67
       67
       +
       		kind: StepKindSystem,

     

       68
       68
       +
       		name: "Clone repository into workspace",

     

       69
       69
       +
       		commands: []string{

     

       70
       70
       +
       			"git init",

     

       71
       71
       +
       			fmt.Sprintf("git remote add origin %s", repoURL),

     

       72
       72
       +
       			fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")),

     

       73
       73
       +
       			"git checkout FETCH_HEAD",

     

       74
       74
       +
       		},

     

       75
       75
       +
       	}

     

       76
       76
       +
       }

     

       77
       77
       +
       

     

       78
       78
       +
       // extractCommitSHA extracts the commit SHA from trigger metadata based on trigger type

     

       79
       79
       +
       func extractCommitSHA(tr tangled.Pipeline_TriggerMetadata) (string, error) {

     

       80
       80
       +
       	switch workflow.TriggerKind(tr.Kind) {

     

       81
       81
       +
       	case workflow.TriggerKindPush:

     

       82
       82
       +
       		if tr.Push == nil {

     

       83
       83
       +
       			return "", fmt.Errorf("push trigger metadata is nil")

     

       84
       84
       +
       		}

     

       85
       85
       +
       		return tr.Push.NewSha, nil

     

       86
       86
       +
       

     

       87
       87
       +
       	case workflow.TriggerKindPullRequest:

     

       88
       88
       +
       		if tr.PullRequest == nil {

     

       89
       89
       +
       			return "", fmt.Errorf("pull request trigger metadata is nil")

     

       90
       90
       +
       		}

     

       91
       91
       +
       		return tr.PullRequest.SourceSha, nil

     

       92
       92
       +
       

     

       93
       93
       +
       	case workflow.TriggerKindManual:

     

       94
       94
       +
       		// Manual triggers don't have an explicit SHA in the metadata

     

       95
       95
       +
       		// For now, return empty string - could be enhanced to fetch from default branch

     

       96
       96
       +
       		// TODO: Implement manual trigger SHA resolution (fetch default branch HEAD)

     

       97
       97
       +
       		return "", nil

     

       98
       98
       +
       

     

       99
       99
       +
       	default:

     

       100
       100
       +
       		return "", fmt.Errorf("unknown trigger kind: %s", tr.Kind)

     

       101
       101
       +
       	}

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       // BuildRepoURL constructs the repository URL from repo metadata.

     

       105
       105
       +
       func BuildRepoURL(repo *tangled.Pipeline_TriggerRepo, devMode bool) string {

     

       106
       106
       +
       	if repo == nil {

     

       107
       107
       +
       		return ""

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

       110
       110
       +
       	scheme := "https://"

     

       111
       111
       +
       	if devMode {

     

       112
       112
       +
       		scheme = "http://"

     

       113
       113
       +
       	}

     

       114
       114
       +
       

     

       115
       115
       +
       	// Get host from knot

     

       116
       116
       +
       	host := repo.Knot

     

       117
       117
       +
       

     

       118
       118
       +
       	// In dev mode, replace localhost with host.docker.internal for Docker networking

     

       119
       119
       +
       	if devMode && strings.Contains(host, "localhost") {

     

       120
       120
       +
       		host = strings.ReplaceAll(host, "localhost", "host.docker.internal")

     

       121
       121
       +
       	}

     

       122
       122
       +
       

     

       123
       123
       +
       	// Build URL: {scheme}{knot}/{did}/{repo}

     

       124
       124
       +
       	return fmt.Sprintf("%s%s/%s/%s", scheme, host, repo.Did, repo.Repo)

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       // buildFetchArgs constructs the arguments for git fetch based on clone options

     

       128
       128
       +
       func buildFetchArgs(clone tangled.Pipeline_CloneOpts, sha string) []string {

     

       129
       129
       +
       	args := []string{}

     

       130
       130
       +
       

     

       131
       131
       +
       	// Set fetch depth (default to 1 for shallow clone)

     

       132
       132
       +
       	depth := clone.Depth

     

       133
       133
       +
       	if depth == 0 {

     

       134
       134
       +
       		depth = 1

     

       135
       135
       +
       	}

     

       136
       136
       +
       	args = append(args, fmt.Sprintf("--depth=%d", depth))

     

       137
       137
       +
       

     

       138
       138
       +
       	// Add submodules if requested

     

       139
       139
       +
       	if clone.Submodules {

     

       140
       140
       +
       		args = append(args, "--recurse-submodules=yes")

     

       141
       141
       +
       	}

     

       142
       142
       +
       

     

       143
       143
       +
       	// Add remote and SHA

     

       144
       144
       +
       	args = append(args, "origin")

     

       145
       145
       +
       	if sha != "" {

     

       146
       146
       +
       		args = append(args, sha)

     

       147
       147
       +
       	}

     

       148
       148
       +
       

     

       149
       149
       +
       	return args

     

       150
       150
       +
       }

+371

spindle/models/clone_test.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"strings"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       func TestBuildCloneStep_PushTrigger(t *testing.T) {

     

       12
       12
       +
       	twf := tangled.Pipeline_Workflow{

     

       13
       13
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       14
       14
       +
       			Depth:      1,

     

       15
       15
       +
       			Submodules: false,

     

       16
       16
       +
       			Skip:       false,

     

       17
       17
       +
       		},

     

       18
       18
       +
       	}

     

       19
       19
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       20
       20
       +
       		Kind: string(workflow.TriggerKindPush),

     

       21
       21
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       22
       22
       +
       			NewSha: "abc123",

     

       23
       23
       +
       			OldSha: "def456",

     

       24
       24
       +
       			Ref:    "refs/heads/main",

     

       25
       25
       +
       		},

     

       26
       26
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       27
       27
       +
       			Knot: "example.com",

     

       28
       28
       +
       			Did:  "did:plc:user123",

     

       29
       29
       +
       			Repo: "my-repo",

     

       30
       30
       +
       		},

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	step := BuildCloneStep(twf, tr, false)

     

       34
       34
       +
       

     

       35
       35
       +
       	if step.Kind() != StepKindSystem {

     

       36
       36
       +
       		t.Errorf("Expected StepKindSystem, got %v", step.Kind())

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	if step.Name() != "Clone repository into workspace" {

     

       40
       40
       +
       		t.Errorf("Expected 'Clone repository into workspace', got '%s'", step.Name())

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	commands := step.Commands()

     

       44
       44
       +
       	if len(commands) != 4 {

     

       45
       45
       +
       		t.Errorf("Expected 4 commands, got %d", len(commands))

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	// Verify commands contain expected git operations

     

       49
       49
       +
       	allCmds := strings.Join(commands, " ")

     

       50
       50
       +
       	if !strings.Contains(allCmds, "git init") {

     

       51
       51
       +
       		t.Error("Commands should contain 'git init'")

     

       52
       52
       +
       	}

     

       53
       53
       +
       	if !strings.Contains(allCmds, "git remote add origin") {

     

       54
       54
       +
       		t.Error("Commands should contain 'git remote add origin'")

     

       55
       55
       +
       	}

     

       56
       56
       +
       	if !strings.Contains(allCmds, "git fetch") {

     

       57
       57
       +
       		t.Error("Commands should contain 'git fetch'")

     

       58
       58
       +
       	}

     

       59
       59
       +
       	if !strings.Contains(allCmds, "abc123") {

     

       60
       60
       +
       		t.Error("Commands should contain commit SHA")

     

       61
       61
       +
       	}

     

       62
       62
       +
       	if !strings.Contains(allCmds, "git checkout FETCH_HEAD") {

     

       63
       63
       +
       		t.Error("Commands should contain 'git checkout FETCH_HEAD'")

     

       64
       64
       +
       	}

     

       65
       65
       +
       	if !strings.Contains(allCmds, "https://example.com/did:plc:user123/my-repo") {

     

       66
       66
       +
       		t.Error("Commands should contain expected repo URL")

     

       67
       67
       +
       	}

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       70
       70
       +
       func TestBuildCloneStep_PullRequestTrigger(t *testing.T) {

     

       71
       71
       +
       	twf := tangled.Pipeline_Workflow{

     

       72
       72
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       73
       73
       +
       			Depth: 1,

     

       74
       74
       +
       			Skip:  false,

     

       75
       75
       +
       		},

     

       76
       76
       +
       	}

     

       77
       77
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       78
       78
       +
       		Kind: string(workflow.TriggerKindPullRequest),

     

       79
       79
       +
       		PullRequest: &tangled.Pipeline_PullRequestTriggerData{

     

       80
       80
       +
       			SourceSha:    "pr-sha-789",

     

       81
       81
       +
       			SourceBranch: "feature-branch",

     

       82
       82
       +
       			TargetBranch: "main",

     

       83
       83
       +
       			Action:       "opened",

     

       84
       84
       +
       		},

     

       85
       85
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       86
       86
       +
       			Knot: "example.com",

     

       87
       87
       +
       			Did:  "did:plc:user123",

     

       88
       88
       +
       			Repo: "my-repo",

     

       89
       89
       +
       		},

     

       90
       90
       +
       	}

     

       91
       91
       +
       

     

       92
       92
       +
       	step := BuildCloneStep(twf, tr, false)

     

       93
       93
       +
       

     

       94
       94
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       95
       95
       +
       	if !strings.Contains(allCmds, "pr-sha-789") {

     

       96
       96
       +
       		t.Error("Commands should contain PR commit SHA")

     

       97
       97
       +
       	}

     

       98
       98
       +
       }

     

       99
       99
       +
       

     

       100
       100
       +
       func TestBuildCloneStep_ManualTrigger(t *testing.T) {

     

       101
       101
       +
       	twf := tangled.Pipeline_Workflow{

     

       102
       102
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       103
       103
       +
       			Depth: 1,

     

       104
       104
       +
       			Skip:  false,

     

       105
       105
       +
       		},

     

       106
       106
       +
       	}

     

       107
       107
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       108
       108
       +
       		Kind: string(workflow.TriggerKindManual),

     

       109
       109
       +
       		Manual: &tangled.Pipeline_ManualTriggerData{

     

       110
       110
       +
       			Inputs: nil,

     

       111
       111
       +
       		},

     

       112
       112
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       113
       113
       +
       			Knot: "example.com",

     

       114
       114
       +
       			Did:  "did:plc:user123",

     

       115
       115
       +
       			Repo: "my-repo",

     

       116
       116
       +
       		},

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	step := BuildCloneStep(twf, tr, false)

     

       120
       120
       +
       

     

       121
       121
       +
       	// Manual triggers don't have a SHA yet (TODO), so git fetch won't include a SHA

     

       122
       122
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       123
       123
       +
       	// Should still have basic git commands

     

       124
       124
       +
       	if !strings.Contains(allCmds, "git init") {

     

       125
       125
       +
       		t.Error("Commands should contain 'git init'")

     

       126
       126
       +
       	}

     

       127
       127
       +
       	if !strings.Contains(allCmds, "git fetch") {

     

       128
       128
       +
       		t.Error("Commands should contain 'git fetch'")

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

     

       131
       131
       +
       

     

       132
       132
       +
       func TestBuildCloneStep_SkipFlag(t *testing.T) {

     

       133
       133
       +
       	twf := tangled.Pipeline_Workflow{

     

       134
       134
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       135
       135
       +
       			Skip: true,

     

       136
       136
       +
       		},

     

       137
       137
       +
       	}

     

       138
       138
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       139
       139
       +
       		Kind: string(workflow.TriggerKindPush),

     

       140
       140
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       141
       141
       +
       			NewSha: "abc123",

     

       142
       142
       +
       		},

     

       143
       143
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       144
       144
       +
       			Knot: "example.com",

     

       145
       145
       +
       			Did:  "did:plc:user123",

     

       146
       146
       +
       			Repo: "my-repo",

     

       147
       147
       +
       		},

     

       148
       148
       +
       	}

     

       149
       149
       +
       

     

       150
       150
       +
       	step := BuildCloneStep(twf, tr, false)

     

       151
       151
       +
       

     

       152
       152
       +
       	// Empty step when skip is true

     

       153
       153
       +
       	if step.Name() != "" {

     

       154
       154
       +
       		t.Error("Expected empty step name when Skip is true")

     

       155
       155
       +
       	}

     

       156
       156
       +
       	if len(step.Commands()) != 0 {

     

       157
       157
       +
       		t.Errorf("Expected no commands when Skip is true, got %d commands", len(step.Commands()))

     

       158
       158
       +
       	}

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       161
       161
       +
       func TestBuildCloneStep_DevMode(t *testing.T) {

     

       162
       162
       +
       	twf := tangled.Pipeline_Workflow{

     

       163
       163
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       164
       164
       +
       			Depth: 1,

     

       165
       165
       +
       			Skip:  false,

     

       166
       166
       +
       		},

     

       167
       167
       +
       	}

     

       168
       168
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       169
       169
       +
       		Kind: string(workflow.TriggerKindPush),

     

       170
       170
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       171
       171
       +
       			NewSha: "abc123",

     

       172
       172
       +
       		},

     

       173
       173
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       174
       174
       +
       			Knot: "localhost:3000",

     

       175
       175
       +
       			Did:  "did:plc:user123",

     

       176
       176
       +
       			Repo: "my-repo",

     

       177
       177
       +
       		},

     

       178
       178
       +
       	}

     

       179
       179
       +
       

     

       180
       180
       +
       	step := BuildCloneStep(twf, tr, true)

     

       181
       181
       +
       

     

       182
       182
       +
       	// In dev mode, should use http:// and replace localhost with host.docker.internal

     

       183
       183
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       184
       184
       +
       	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"

     

       185
       185
       +
       	if !strings.Contains(allCmds, expectedURL) {

     

       186
       186
       +
       		t.Errorf("Expected dev mode URL '%s' in commands", expectedURL)

     

       187
       187
       +
       	}

     

       188
       188
       +
       }

     

       189
       189
       +
       

     

       190
       190
       +
       func TestBuildCloneStep_DepthAndSubmodules(t *testing.T) {

     

       191
       191
       +
       	twf := tangled.Pipeline_Workflow{

     

       192
       192
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       193
       193
       +
       			Depth:      10,

     

       194
       194
       +
       			Submodules: true,

     

       195
       195
       +
       			Skip:       false,

     

       196
       196
       +
       		},

     

       197
       197
       +
       	}

     

       198
       198
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       199
       199
       +
       		Kind: string(workflow.TriggerKindPush),

     

       200
       200
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       201
       201
       +
       			NewSha: "abc123",

     

       202
       202
       +
       		},

     

       203
       203
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       204
       204
       +
       			Knot: "example.com",

     

       205
       205
       +
       			Did:  "did:plc:user123",

     

       206
       206
       +
       			Repo: "my-repo",

     

       207
       207
       +
       		},

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	step := BuildCloneStep(twf, tr, false)

     

       211
       211
       +
       

     

       212
       212
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       213
       213
       +
       	if !strings.Contains(allCmds, "--depth=10") {

     

       214
       214
       +
       		t.Error("Commands should contain '--depth=10'")

     

       215
       215
       +
       	}

     

       216
       216
       +
       

     

       217
       217
       +
       	if !strings.Contains(allCmds, "--recurse-submodules=yes") {

     

       218
       218
       +
       		t.Error("Commands should contain '--recurse-submodules=yes'")

     

       219
       219
       +
       	}

     

       220
       220
       +
       }

     

       221
       221
       +
       

     

       222
       222
       +
       func TestBuildCloneStep_DefaultDepth(t *testing.T) {

     

       223
       223
       +
       	twf := tangled.Pipeline_Workflow{

     

       224
       224
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       225
       225
       +
       			Depth: 0, // Default should be 1

     

       226
       226
       +
       			Skip:  false,

     

       227
       227
       +
       		},

     

       228
       228
       +
       	}

     

       229
       229
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       230
       230
       +
       		Kind: string(workflow.TriggerKindPush),

     

       231
       231
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       232
       232
       +
       			NewSha: "abc123",

     

       233
       233
       +
       		},

     

       234
       234
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       235
       235
       +
       			Knot: "example.com",

     

       236
       236
       +
       			Did:  "did:plc:user123",

     

       237
       237
       +
       			Repo: "my-repo",

     

       238
       238
       +
       		},

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	step := BuildCloneStep(twf, tr, false)

     

       242
       242
       +
       

     

       243
       243
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       244
       244
       +
       	if !strings.Contains(allCmds, "--depth=1") {

     

       245
       245
       +
       		t.Error("Commands should default to '--depth=1'")

     

       246
       246
       +
       	}

     

       247
       247
       +
       }

     

       248
       248
       +
       

     

       249
       249
       +
       func TestBuildCloneStep_NilPushData(t *testing.T) {

     

       250
       250
       +
       	twf := tangled.Pipeline_Workflow{

     

       251
       251
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       252
       252
       +
       			Depth: 1,

     

       253
       253
       +
       			Skip:  false,

     

       254
       254
       +
       		},

     

       255
       255
       +
       	}

     

       256
       256
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       257
       257
       +
       		Kind: string(workflow.TriggerKindPush),

     

       258
       258
       +
       		Push: nil, // Nil push data should create error step

     

       259
       259
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       260
       260
       +
       			Knot: "example.com",

     

       261
       261
       +
       			Did:  "did:plc:user123",

     

       262
       262
       +
       			Repo: "my-repo",

     

       263
       263
       +
       		},

     

       264
       264
       +
       	}

     

       265
       265
       +
       

     

       266
       266
       +
       	step := BuildCloneStep(twf, tr, false)

     

       267
       267
       +
       

     

       268
       268
       +
       	// Should return an error step

     

       269
       269
       +
       	if !strings.Contains(step.Name(), "error") {

     

       270
       270
       +
       		t.Error("Expected error in step name when push data is nil")

     

       271
       271
       +
       	}

     

       272
       272
       +
       

     

       273
       273
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       274
       274
       +
       	if !strings.Contains(allCmds, "Failed to get clone info") {

     

       275
       275
       +
       		t.Error("Commands should contain error message")

     

       276
       276
       +
       	}

     

       277
       277
       +
       	if !strings.Contains(allCmds, "exit 1") {

     

       278
       278
       +
       		t.Error("Commands should exit with error")

     

       279
       279
       +
       	}

     

       280
       280
       +
       }

     

       281
       281
       +
       

     

       282
       282
       +
       func TestBuildCloneStep_NilPRData(t *testing.T) {

     

       283
       283
       +
       	twf := tangled.Pipeline_Workflow{

     

       284
       284
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       285
       285
       +
       			Depth: 1,

     

       286
       286
       +
       			Skip:  false,

     

       287
       287
       +
       		},

     

       288
       288
       +
       	}

     

       289
       289
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       290
       290
       +
       		Kind:        string(workflow.TriggerKindPullRequest),

     

       291
       291
       +
       		PullRequest: nil, // Nil PR data should create error step

     

       292
       292
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       293
       293
       +
       			Knot: "example.com",

     

       294
       294
       +
       			Did:  "did:plc:user123",

     

       295
       295
       +
       			Repo: "my-repo",

     

       296
       296
       +
       		},

     

       297
       297
       +
       	}

     

       298
       298
       +
       

     

       299
       299
       +
       	step := BuildCloneStep(twf, tr, false)

     

       300
       300
       +
       

     

       301
       301
       +
       	// Should return an error step

     

       302
       302
       +
       	if !strings.Contains(step.Name(), "error") {

     

       303
       303
       +
       		t.Error("Expected error in step name when pull request data is nil")

     

       304
       304
       +
       	}

     

       305
       305
       +
       

     

       306
       306
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       307
       307
       +
       	if !strings.Contains(allCmds, "Failed to get clone info") {

     

       308
       308
       +
       		t.Error("Commands should contain error message")

     

       309
       309
       +
       	}

     

       310
       310
       +
       }

     

       311
       311
       +
       

     

       312
       312
       +
       func TestBuildCloneStep_UnknownTriggerKind(t *testing.T) {

     

       313
       313
       +
       	twf := tangled.Pipeline_Workflow{

     

       314
       314
       +
       		Clone: &tangled.Pipeline_CloneOpts{

     

       315
       315
       +
       			Depth: 1,

     

       316
       316
       +
       			Skip:  false,

     

       317
       317
       +
       		},

     

       318
       318
       +
       	}

     

       319
       319
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       320
       320
       +
       		Kind: "unknown_trigger",

     

       321
       321
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       322
       322
       +
       			Knot: "example.com",

     

       323
       323
       +
       			Did:  "did:plc:user123",

     

       324
       324
       +
       			Repo: "my-repo",

     

       325
       325
       +
       		},

     

       326
       326
       +
       	}

     

       327
       327
       +
       

     

       328
       328
       +
       	step := BuildCloneStep(twf, tr, false)

     

       329
       329
       +
       

     

       330
       330
       +
       	// Should return an error step

     

       331
       331
       +
       	if !strings.Contains(step.Name(), "error") {

     

       332
       332
       +
       		t.Error("Expected error in step name for unknown trigger kind")

     

       333
       333
       +
       	}

     

       334
       334
       +
       

     

       335
       335
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       336
       336
       +
       	if !strings.Contains(allCmds, "unknown trigger kind") {

     

       337
       337
       +
       		t.Error("Commands should contain error message about unknown trigger kind")

     

       338
       338
       +
       	}

     

       339
       339
       +
       }

     

       340
       340
       +
       

     

       341
       341
       +
       func TestBuildCloneStep_NilCloneOpts(t *testing.T) {

     

       342
       342
       +
       	twf := tangled.Pipeline_Workflow{

     

       343
       343
       +
       		Clone: nil, // Nil clone options should use defaults

     

       344
       344
       +
       	}

     

       345
       345
       +
       	tr := tangled.Pipeline_TriggerMetadata{

     

       346
       346
       +
       		Kind: string(workflow.TriggerKindPush),

     

       347
       347
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       348
       348
       +
       			NewSha: "abc123",

     

       349
       349
       +
       		},

     

       350
       350
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       351
       351
       +
       			Knot: "example.com",

     

       352
       352
       +
       			Did:  "did:plc:user123",

     

       353
       353
       +
       			Repo: "my-repo",

     

       354
       354
       +
       		},

     

       355
       355
       +
       	}

     

       356
       356
       +
       

     

       357
       357
       +
       	step := BuildCloneStep(twf, tr, false)

     

       358
       358
       +
       

     

       359
       359
       +
       	// Should still work with default options

     

       360
       360
       +
       	if step.Kind() != StepKindSystem {

     

       361
       361
       +
       		t.Errorf("Expected StepKindSystem, got %v", step.Kind())

     

       362
       362
       +
       	}

     

       363
       363
       +
       

     

       364
       364
       +
       	allCmds := strings.Join(step.Commands(), " ")

     

       365
       365
       +
       	if !strings.Contains(allCmds, "--depth=1") {

     

       366
       366
       +
       		t.Error("Commands should default to '--depth=1' when Clone is nil")

     

       367
       367
       +
       	}

     

       368
       368
       +
       	if !strings.Contains(allCmds, "git init") {

     

       369
       369
       +
       		t.Error("Commands should contain 'git init'")

     

       370
       370
       +
       	}

     

       371
       371
       +
       }

+14 -11

spindle/models/logger.go

···

       37
       37
        
       	return l.file.Close()

     

       38
       38
        
       }

     

       39
       39
        
       

     

       40
       40
       -
       func (l *WorkflowLogger) DataWriter(stream string) io.Writer {

     

       41
       41
       -
       	// TODO: emit stream

     

       40
       40
       +
       func (l *WorkflowLogger) DataWriter(idx int, stream string) io.Writer {

     

       42
       41
        
       	return &dataWriter{

     

       43
       42
        
       		logger: l,

     

       43
       43
       +
       		idx:    idx,

     

       44
       44
        
       		stream: stream,

     

       45
       45
        
       	}

     

       46
       46
        
       }

     

       47
       47
        
       

     

       48
       48
       -
       func (l *WorkflowLogger) ControlWriter(idx int, step Step) io.Writer {

     

       48
       48
       +
       func (l *WorkflowLogger) ControlWriter(idx int, step Step, stepStatus StepStatus) io.Writer {

     

       49
       49
        
       	return &controlWriter{

     

       50
       50
       -
       		logger: l,

     

       51
       51
       -
       		idx:    idx,

     

       52
       52
       -
       		step:   step,

     

       50
       50
       +
       		logger:     l,

     

       51
       51
       +
       		idx:        idx,

     

       52
       52
       +
       		step:       step,

     

       53
       53
       +
       		stepStatus: stepStatus,

     

       53
       54
        
       	}

     

       54
       55
        
       }

     

       55
       56
        
       

     

       56
       57
        
       type dataWriter struct {

     

       57
       58
        
       	logger *WorkflowLogger

     

       59
       59
       +
       	idx    int

     

       58
       60
        
       	stream string

     

       59
       61
        
       }

     

       60
       62
        
       

     

       61
       63
        
       func (w *dataWriter) Write(p []byte) (int, error) {

     

       62
       64
        
       	line := strings.TrimRight(string(p), "\r\n")

     

       63
       63
       -
       	entry := NewDataLogLine(line, w.stream)

     

       65
       65
       +
       	entry := NewDataLogLine(w.idx, line, w.stream)

     

       64
       66
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       65
       67
        
       		return 0, err

     

       66
       68
        
       	}

     
···

       68
       70
        
       }

     

       69
       71
        
       

     

       70
       72
        
       type controlWriter struct {

     

       71
       71
       -
       	logger *WorkflowLogger

     

       72
       72
       -
       	idx    int

     

       73
       73
       -
       	step   Step

     

       73
       73
       +
       	logger     *WorkflowLogger

     

       74
       74
       +
       	idx        int

     

       75
       75
       +
       	step       Step

     

       76
       76
       +
       	stepStatus StepStatus

     

       74
       77
        
       }

     

       75
       78
        
       

     

       76
       79
        
       func (w *controlWriter) Write(_ []byte) (int, error) {

     

       77
       77
       -
       	entry := NewControlLogLine(w.idx, w.step)

     

       80
       80
       +
       	entry := NewControlLogLine(w.idx, w.step, w.stepStatus)

     

       78
       81
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       79
       82
        
       		return 0, err

     

       80
       83
        
       	}

+23 -8

spindle/models/models.go

···

       4
       4
        
       	"fmt"

     

       5
       5
        
       	"regexp"

     

       6
       6
        
       	"slices"

     

       7
       7
       +
       	"time"

     

       7
       8
        
       

     

       8
       9
        
       	"tangled.org/core/api/tangled"

     

       9
       10
        
       

     
···

       76
       77
        
       var (

     

       77
       78
        
       	// step log data

     

       78
       79
        
       	LogKindData LogKind = "data"

     

       79
       79
       -
       	// indicates start/end of a step

     

       80
       80
       +
       	// indicates status of a step

     

       80
       81
        
       	LogKindControl LogKind = "control"

     

       81
       82
        
       )

     

       82
       83
        
       

     

       84
       84
       +
       // step status indicator in control log lines

     

       85
       85
       +
       type StepStatus string

     

       86
       86
       +
       

     

       87
       87
       +
       var (

     

       88
       88
       +
       	StepStatusStart StepStatus = "start"

     

       89
       89
       +
       	StepStatusEnd   StepStatus = "end"

     

       90
       90
       +
       )

     

       91
       91
       +
       

     

       83
       92
        
       type LogLine struct {

     

       84
       84
       -
       	Kind    LogKind `json:"kind"`

     

       85
       85
       -
       	Content string  `json:"content"`

     

       93
       93
       +
       	Kind    LogKind   `json:"kind"`

     

       94
       94
       +
       	Content string    `json:"content"`

     

       95
       95
       +
       	Time    time.Time `json:"time"`

     

       96
       96
       +
       	StepId  int       `json:"step_id"`

     

       86
       97
        
       

     

       87
       98
        
       	// fields if kind is "data"

     

       88
       99
        
       	Stream string `json:"stream,omitempty"`

     

       89
       100
        
       

     

       90
       101
        
       	// fields if kind is "control"

     

       91
       91
       -
       	StepId      int      `json:"step_id,omitempty"`

     

       92
       92
       -
       	StepKind    StepKind `json:"step_kind,omitempty"`

     

       93
       93
       -
       	StepCommand string   `json:"step_command,omitempty"`

     

       102
       102
       +
       	StepStatus  StepStatus `json:"step_status,omitempty"`

     

       103
       103
       +
       	StepKind    StepKind   `json:"step_kind,omitempty"`

     

       104
       104
       +
       	StepCommand string     `json:"step_command,omitempty"`

     

       94
       105
        
       }

     

       95
       106
        
       

     

       96
       96
       -
       func NewDataLogLine(content, stream string) LogLine {

     

       107
       107
       +
       func NewDataLogLine(idx int, content, stream string) LogLine {

     

       97
       108
        
       	return LogLine{

     

       98
       109
        
       		Kind:    LogKindData,

     

       110
       110
       +
       		Time:    time.Now(),

     

       99
       111
        
       		Content: content,

     

       112
       112
       +
       		StepId:  idx,

     

       100
       113
        
       		Stream:  stream,

     

       101
       114
        
       	}

     

       102
       115
        
       }

     

       103
       116
        
       

     

       104
       104
       -
       func NewControlLogLine(idx int, step Step) LogLine {

     

       117
       117
       +
       func NewControlLogLine(idx int, step Step, status StepStatus) LogLine {

     

       105
       118
        
       	return LogLine{

     

       106
       119
        
       		Kind:        LogKindControl,

     

       120
       120
       +
       		Time:        time.Now(),

     

       107
       121
        
       		Content:     step.Name(),

     

       108
       122
        
       		StepId:      idx,

     

       123
       123
       +
       		StepStatus:  status,

     

       109
       124
        
       		StepKind:    step.Kind(),

     

       110
       125
        
       		StepCommand: step.Command(),

     

       111
       126
        
       	}

+4 -3

spindle/models/pipeline.go

···

       22
       22
        
       )

     

       23
       23
        
       

     

       24
       24
        
       type Workflow struct {

     

       25
       25
       -
       	Steps []Step

     

       26
       26
       -
       	Name  string

     

       27
       27
       -
       	Data  any

     

       25
       25
       +
       	Steps       []Step

     

       26
       26
       +
       	Name        string

     

       27
       27
       +
       	Data        any

     

       28
       28
       +
       	Environment map[string]string

     

       28
       29
        
       }

+77

spindle/models/pipeline_env.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"strings"

     

       5
       5
       +
       

     

       6
       6
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

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

     

       8
       8
       +
       	"tangled.org/core/workflow"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // PipelineEnvVars extracts environment variables from pipeline trigger metadata.

     

       12
       12
       +
       // These are framework-provided variables that are injected into workflow steps.

     

       13
       13
       +
       func PipelineEnvVars(tr *tangled.Pipeline_TriggerMetadata, pipelineId PipelineId, devMode bool) map[string]string {

     

       14
       14
       +
       	if tr == nil {

     

       15
       15
       +
       		return nil

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	env := make(map[string]string)

     

       19
       19
       +
       

     

       20
       20
       +
       	// Standard CI environment variable

     

       21
       21
       +
       	env["CI"] = "true"

     

       22
       22
       +
       

     

       23
       23
       +
       	env["TANGLED_PIPELINE_ID"] = pipelineId.Rkey

     

       24
       24
       +
       

     

       25
       25
       +
       	// Repo info

     

       26
       26
       +
       	if tr.Repo != nil {

     

       27
       27
       +
       		env["TANGLED_REPO_KNOT"] = tr.Repo.Knot

     

       28
       28
       +
       		env["TANGLED_REPO_DID"] = tr.Repo.Did

     

       29
       29
       +
       		env["TANGLED_REPO_NAME"] = tr.Repo.Repo

     

       30
       30
       +
       		env["TANGLED_REPO_DEFAULT_BRANCH"] = tr.Repo.DefaultBranch

     

       31
       31
       +
       		env["TANGLED_REPO_URL"] = BuildRepoURL(tr.Repo, devMode)

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	switch workflow.TriggerKind(tr.Kind) {

     

       35
       35
       +
       	case workflow.TriggerKindPush:

     

       36
       36
       +
       		if tr.Push != nil {

     

       37
       37
       +
       			refName := plumbing.ReferenceName(tr.Push.Ref)

     

       38
       38
       +
       			refType := "branch"

     

       39
       39
       +
       			if refName.IsTag() {

     

       40
       40
       +
       				refType = "tag"

     

       41
       41
       +
       			}

     

       42
       42
       +
       

     

       43
       43
       +
       			env["TANGLED_REF"] = tr.Push.Ref

     

       44
       44
       +
       			env["TANGLED_REF_NAME"] = refName.Short()

     

       45
       45
       +
       			env["TANGLED_REF_TYPE"] = refType

     

       46
       46
       +
       			env["TANGLED_SHA"] = tr.Push.NewSha

     

       47
       47
       +
       			env["TANGLED_COMMIT_SHA"] = tr.Push.NewSha

     

       48
       48
       +
       		}

     

       49
       49
       +
       

     

       50
       50
       +
       	case workflow.TriggerKindPullRequest:

     

       51
       51
       +
       		if tr.PullRequest != nil {

     

       52
       52
       +
       			// For PRs, the "ref" is the source branch

     

       53
       53
       +
       			env["TANGLED_REF"] = "refs/heads/" + tr.PullRequest.SourceBranch

     

       54
       54
       +
       			env["TANGLED_REF_NAME"] = tr.PullRequest.SourceBranch

     

       55
       55
       +
       			env["TANGLED_REF_TYPE"] = "branch"

     

       56
       56
       +
       			env["TANGLED_SHA"] = tr.PullRequest.SourceSha

     

       57
       57
       +
       			env["TANGLED_COMMIT_SHA"] = tr.PullRequest.SourceSha

     

       58
       58
       +
       

     

       59
       59
       +
       			// PR-specific variables

     

       60
       60
       +
       			env["TANGLED_PR_SOURCE_BRANCH"] = tr.PullRequest.SourceBranch

     

       61
       61
       +
       			env["TANGLED_PR_TARGET_BRANCH"] = tr.PullRequest.TargetBranch

     

       62
       62
       +
       			env["TANGLED_PR_SOURCE_SHA"] = tr.PullRequest.SourceSha

     

       63
       63
       +
       			env["TANGLED_PR_ACTION"] = tr.PullRequest.Action

     

       64
       64
       +
       		}

     

       65
       65
       +
       

     

       66
       66
       +
       	case workflow.TriggerKindManual:

     

       67
       67
       +
       		// Manual triggers may not have ref/sha info

     

       68
       68
       +
       		// Include any manual inputs if present

     

       69
       69
       +
       		if tr.Manual != nil {

     

       70
       70
       +
       			for _, pair := range tr.Manual.Inputs {

     

       71
       71
       +
       				env["TANGLED_INPUT_"+strings.ToUpper(pair.Key)] = pair.Value

     

       72
       72
       +
       			}

     

       73
       73
       +
       		}

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	return env

     

       77
       77
       +
       }

+260

spindle/models/pipeline_env_test.go

···

       1
       1
       +
       package models

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       

     

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

     

       7
       7
       +
       	"tangled.org/core/workflow"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       func TestPipelineEnvVars_PushBranch(t *testing.T) {

     

       11
       11
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       12
       12
       +
       		Kind: string(workflow.TriggerKindPush),

     

       13
       13
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       14
       14
       +
       			NewSha: "abc123def456",

     

       15
       15
       +
       			OldSha: "000000000000",

     

       16
       16
       +
       			Ref:    "refs/heads/main",

     

       17
       17
       +
       		},

     

       18
       18
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       19
       19
       +
       			Knot:          "example.com",

     

       20
       20
       +
       			Did:           "did:plc:user123",

     

       21
       21
       +
       			Repo:          "my-repo",

     

       22
       22
       +
       			DefaultBranch: "main",

     

       23
       23
       +
       		},

     

       24
       24
       +
       	}

     

       25
       25
       +
       	id := PipelineId{

     

       26
       26
       +
       		Knot: "example.com",

     

       27
       27
       +
       		Rkey: "123123",

     

       28
       28
       +
       	}

     

       29
       29
       +
       	env := PipelineEnvVars(tr, id, false)

     

       30
       30
       +
       

     

       31
       31
       +
       	// Check standard CI variable

     

       32
       32
       +
       	if env["CI"] != "true" {

     

       33
       33
       +
       		t.Errorf("Expected CI='true', got '%s'", env["CI"])

     

       34
       34
       +
       	}

     

       35
       35
       +
       

     

       36
       36
       +
       	// Check ref variables

     

       37
       37
       +
       	if env["TANGLED_REF"] != "refs/heads/main" {

     

       38
       38
       +
       		t.Errorf("Expected TANGLED_REF='refs/heads/main', got '%s'", env["TANGLED_REF"])

     

       39
       39
       +
       	}

     

       40
       40
       +
       	if env["TANGLED_REF_NAME"] != "main" {

     

       41
       41
       +
       		t.Errorf("Expected TANGLED_REF_NAME='main', got '%s'", env["TANGLED_REF_NAME"])

     

       42
       42
       +
       	}

     

       43
       43
       +
       	if env["TANGLED_REF_TYPE"] != "branch" {

     

       44
       44
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='branch', got '%s'", env["TANGLED_REF_TYPE"])

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	// Check SHA variables

     

       48
       48
       +
       	if env["TANGLED_SHA"] != "abc123def456" {

     

       49
       49
       +
       		t.Errorf("Expected TANGLED_SHA='abc123def456', got '%s'", env["TANGLED_SHA"])

     

       50
       50
       +
       	}

     

       51
       51
       +
       	if env["TANGLED_COMMIT_SHA"] != "abc123def456" {

     

       52
       52
       +
       		t.Errorf("Expected TANGLED_COMMIT_SHA='abc123def456', got '%s'", env["TANGLED_COMMIT_SHA"])

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	// Check repo variables

     

       56
       56
       +
       	if env["TANGLED_REPO_KNOT"] != "example.com" {

     

       57
       57
       +
       		t.Errorf("Expected TANGLED_REPO_KNOT='example.com', got '%s'", env["TANGLED_REPO_KNOT"])

     

       58
       58
       +
       	}

     

       59
       59
       +
       	if env["TANGLED_REPO_DID"] != "did:plc:user123" {

     

       60
       60
       +
       		t.Errorf("Expected TANGLED_REPO_DID='did:plc:user123', got '%s'", env["TANGLED_REPO_DID"])

     

       61
       61
       +
       	}

     

       62
       62
       +
       	if env["TANGLED_REPO_NAME"] != "my-repo" {

     

       63
       63
       +
       		t.Errorf("Expected TANGLED_REPO_NAME='my-repo', got '%s'", env["TANGLED_REPO_NAME"])

     

       64
       64
       +
       	}

     

       65
       65
       +
       	if env["TANGLED_REPO_DEFAULT_BRANCH"] != "main" {

     

       66
       66
       +
       		t.Errorf("Expected TANGLED_REPO_DEFAULT_BRANCH='main', got '%s'", env["TANGLED_REPO_DEFAULT_BRANCH"])

     

       67
       67
       +
       	}

     

       68
       68
       +
       	if env["TANGLED_REPO_URL"] != "https://example.com/did:plc:user123/my-repo" {

     

       69
       69
       +
       		t.Errorf("Expected TANGLED_REPO_URL='https://example.com/did:plc:user123/my-repo', got '%s'", env["TANGLED_REPO_URL"])

     

       70
       70
       +
       	}

     

       71
       71
       +
       }

     

       72
       72
       +
       

     

       73
       73
       +
       func TestPipelineEnvVars_PushTag(t *testing.T) {

     

       74
       74
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       75
       75
       +
       		Kind: string(workflow.TriggerKindPush),

     

       76
       76
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       77
       77
       +
       			NewSha: "abc123def456",

     

       78
       78
       +
       			OldSha: "000000000000",

     

       79
       79
       +
       			Ref:    "refs/tags/v1.2.3",

     

       80
       80
       +
       		},

     

       81
       81
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       82
       82
       +
       			Knot: "example.com",

     

       83
       83
       +
       			Did:  "did:plc:user123",

     

       84
       84
       +
       			Repo: "my-repo",

     

       85
       85
       +
       		},

     

       86
       86
       +
       	}

     

       87
       87
       +
       	id := PipelineId{

     

       88
       88
       +
       		Knot: "example.com",

     

       89
       89
       +
       		Rkey: "123123",

     

       90
       90
       +
       	}

     

       91
       91
       +
       	env := PipelineEnvVars(tr, id, false)

     

       92
       92
       +
       

     

       93
       93
       +
       	if env["TANGLED_REF"] != "refs/tags/v1.2.3" {

     

       94
       94
       +
       		t.Errorf("Expected TANGLED_REF='refs/tags/v1.2.3', got '%s'", env["TANGLED_REF"])

     

       95
       95
       +
       	}

     

       96
       96
       +
       	if env["TANGLED_REF_NAME"] != "v1.2.3" {

     

       97
       97
       +
       		t.Errorf("Expected TANGLED_REF_NAME='v1.2.3', got '%s'", env["TANGLED_REF_NAME"])

     

       98
       98
       +
       	}

     

       99
       99
       +
       	if env["TANGLED_REF_TYPE"] != "tag" {

     

       100
       100
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='tag', got '%s'", env["TANGLED_REF_TYPE"])

     

       101
       101
       +
       	}

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       func TestPipelineEnvVars_PullRequest(t *testing.T) {

     

       105
       105
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       106
       106
       +
       		Kind: string(workflow.TriggerKindPullRequest),

     

       107
       107
       +
       		PullRequest: &tangled.Pipeline_PullRequestTriggerData{

     

       108
       108
       +
       			SourceBranch: "feature-branch",

     

       109
       109
       +
       			TargetBranch: "main",

     

       110
       110
       +
       			SourceSha:    "pr-sha-789",

     

       111
       111
       +
       			Action:       "opened",

     

       112
       112
       +
       		},

     

       113
       113
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       114
       114
       +
       			Knot: "example.com",

     

       115
       115
       +
       			Did:  "did:plc:user123",

     

       116
       116
       +
       			Repo: "my-repo",

     

       117
       117
       +
       		},

     

       118
       118
       +
       	}

     

       119
       119
       +
       	id := PipelineId{

     

       120
       120
       +
       		Knot: "example.com",

     

       121
       121
       +
       		Rkey: "123123",

     

       122
       122
       +
       	}

     

       123
       123
       +
       	env := PipelineEnvVars(tr, id, false)

     

       124
       124
       +
       

     

       125
       125
       +
       	// Check ref variables for PR

     

       126
       126
       +
       	if env["TANGLED_REF"] != "refs/heads/feature-branch" {

     

       127
       127
       +
       		t.Errorf("Expected TANGLED_REF='refs/heads/feature-branch', got '%s'", env["TANGLED_REF"])

     

       128
       128
       +
       	}

     

       129
       129
       +
       	if env["TANGLED_REF_NAME"] != "feature-branch" {

     

       130
       130
       +
       		t.Errorf("Expected TANGLED_REF_NAME='feature-branch', got '%s'", env["TANGLED_REF_NAME"])

     

       131
       131
       +
       	}

     

       132
       132
       +
       	if env["TANGLED_REF_TYPE"] != "branch" {

     

       133
       133
       +
       		t.Errorf("Expected TANGLED_REF_TYPE='branch', got '%s'", env["TANGLED_REF_TYPE"])

     

       134
       134
       +
       	}

     

       135
       135
       +
       

     

       136
       136
       +
       	// Check SHA variables

     

       137
       137
       +
       	if env["TANGLED_SHA"] != "pr-sha-789" {

     

       138
       138
       +
       		t.Errorf("Expected TANGLED_SHA='pr-sha-789', got '%s'", env["TANGLED_SHA"])

     

       139
       139
       +
       	}

     

       140
       140
       +
       	if env["TANGLED_COMMIT_SHA"] != "pr-sha-789" {

     

       141
       141
       +
       		t.Errorf("Expected TANGLED_COMMIT_SHA='pr-sha-789', got '%s'", env["TANGLED_COMMIT_SHA"])

     

       142
       142
       +
       	}

     

       143
       143
       +
       

     

       144
       144
       +
       	// Check PR-specific variables

     

       145
       145
       +
       	if env["TANGLED_PR_SOURCE_BRANCH"] != "feature-branch" {

     

       146
       146
       +
       		t.Errorf("Expected TANGLED_PR_SOURCE_BRANCH='feature-branch', got '%s'", env["TANGLED_PR_SOURCE_BRANCH"])

     

       147
       147
       +
       	}

     

       148
       148
       +
       	if env["TANGLED_PR_TARGET_BRANCH"] != "main" {

     

       149
       149
       +
       		t.Errorf("Expected TANGLED_PR_TARGET_BRANCH='main', got '%s'", env["TANGLED_PR_TARGET_BRANCH"])

     

       150
       150
       +
       	}

     

       151
       151
       +
       	if env["TANGLED_PR_SOURCE_SHA"] != "pr-sha-789" {

     

       152
       152
       +
       		t.Errorf("Expected TANGLED_PR_SOURCE_SHA='pr-sha-789', got '%s'", env["TANGLED_PR_SOURCE_SHA"])

     

       153
       153
       +
       	}

     

       154
       154
       +
       	if env["TANGLED_PR_ACTION"] != "opened" {

     

       155
       155
       +
       		t.Errorf("Expected TANGLED_PR_ACTION='opened', got '%s'", env["TANGLED_PR_ACTION"])

     

       156
       156
       +
       	}

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       func TestPipelineEnvVars_ManualWithInputs(t *testing.T) {

     

       160
       160
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       161
       161
       +
       		Kind: string(workflow.TriggerKindManual),

     

       162
       162
       +
       		Manual: &tangled.Pipeline_ManualTriggerData{

     

       163
       163
       +
       			Inputs: []*tangled.Pipeline_Pair{

     

       164
       164
       +
       				{Key: "version", Value: "1.0.0"},

     

       165
       165
       +
       				{Key: "environment", Value: "production"},

     

       166
       166
       +
       			},

     

       167
       167
       +
       		},

     

       168
       168
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       169
       169
       +
       			Knot: "example.com",

     

       170
       170
       +
       			Did:  "did:plc:user123",

     

       171
       171
       +
       			Repo: "my-repo",

     

       172
       172
       +
       		},

     

       173
       173
       +
       	}

     

       174
       174
       +
       	id := PipelineId{

     

       175
       175
       +
       		Knot: "example.com",

     

       176
       176
       +
       		Rkey: "123123",

     

       177
       177
       +
       	}

     

       178
       178
       +
       	env := PipelineEnvVars(tr, id, false)

     

       179
       179
       +
       

     

       180
       180
       +
       	// Check manual input variables

     

       181
       181
       +
       	if env["TANGLED_INPUT_VERSION"] != "1.0.0" {

     

       182
       182
       +
       		t.Errorf("Expected TANGLED_INPUT_VERSION='1.0.0', got '%s'", env["TANGLED_INPUT_VERSION"])

     

       183
       183
       +
       	}

     

       184
       184
       +
       	if env["TANGLED_INPUT_ENVIRONMENT"] != "production" {

     

       185
       185
       +
       		t.Errorf("Expected TANGLED_INPUT_ENVIRONMENT='production', got '%s'", env["TANGLED_INPUT_ENVIRONMENT"])

     

       186
       186
       +
       	}

     

       187
       187
       +
       

     

       188
       188
       +
       	// Manual triggers shouldn't have ref/sha variables

     

       189
       189
       +
       	if _, ok := env["TANGLED_REF"]; ok {

     

       190
       190
       +
       		t.Error("Manual trigger should not have TANGLED_REF")

     

       191
       191
       +
       	}

     

       192
       192
       +
       	if _, ok := env["TANGLED_SHA"]; ok {

     

       193
       193
       +
       		t.Error("Manual trigger should not have TANGLED_SHA")

     

       194
       194
       +
       	}

     

       195
       195
       +
       }

     

       196
       196
       +
       

     

       197
       197
       +
       func TestPipelineEnvVars_DevMode(t *testing.T) {

     

       198
       198
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       199
       199
       +
       		Kind: string(workflow.TriggerKindPush),

     

       200
       200
       +
       		Push: &tangled.Pipeline_PushTriggerData{

     

       201
       201
       +
       			NewSha: "abc123",

     

       202
       202
       +
       			Ref:    "refs/heads/main",

     

       203
       203
       +
       		},

     

       204
       204
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       205
       205
       +
       			Knot: "localhost:3000",

     

       206
       206
       +
       			Did:  "did:plc:user123",

     

       207
       207
       +
       			Repo: "my-repo",

     

       208
       208
       +
       		},

     

       209
       209
       +
       	}

     

       210
       210
       +
       	id := PipelineId{

     

       211
       211
       +
       		Knot: "example.com",

     

       212
       212
       +
       		Rkey: "123123",

     

       213
       213
       +
       	}

     

       214
       214
       +
       	env := PipelineEnvVars(tr, id, true)

     

       215
       215
       +
       

     

       216
       216
       +
       	// Dev mode should use http:// and replace localhost with host.docker.internal

     

       217
       217
       +
       	expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo"

     

       218
       218
       +
       	if env["TANGLED_REPO_URL"] != expectedURL {

     

       219
       219
       +
       		t.Errorf("Expected TANGLED_REPO_URL='%s', got '%s'", expectedURL, env["TANGLED_REPO_URL"])

     

       220
       220
       +
       	}

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       func TestPipelineEnvVars_NilTrigger(t *testing.T) {

     

       224
       224
       +
       	id := PipelineId{

     

       225
       225
       +
       		Knot: "example.com",

     

       226
       226
       +
       		Rkey: "123123",

     

       227
       227
       +
       	}

     

       228
       228
       +
       	env := PipelineEnvVars(nil, id, false)

     

       229
       229
       +
       

     

       230
       230
       +
       	if env != nil {

     

       231
       231
       +
       		t.Error("Expected nil env for nil trigger")

     

       232
       232
       +
       	}

     

       233
       233
       +
       }

     

       234
       234
       +
       

     

       235
       235
       +
       func TestPipelineEnvVars_NilPushData(t *testing.T) {

     

       236
       236
       +
       	tr := &tangled.Pipeline_TriggerMetadata{

     

       237
       237
       +
       		Kind: string(workflow.TriggerKindPush),

     

       238
       238
       +
       		Push: nil,

     

       239
       239
       +
       		Repo: &tangled.Pipeline_TriggerRepo{

     

       240
       240
       +
       			Knot: "example.com",

     

       241
       241
       +
       			Did:  "did:plc:user123",

     

       242
       242
       +
       			Repo: "my-repo",

     

       243
       243
       +
       		},

     

       244
       244
       +
       	}

     

       245
       245
       +
       	id := PipelineId{

     

       246
       246
       +
       		Knot: "example.com",

     

       247
       247
       +
       		Rkey: "123123",

     

       248
       248
       +
       	}

     

       249
       249
       +
       	env := PipelineEnvVars(tr, id, false)

     

       250
       250
       +
       

     

       251
       251
       +
       	// Should still have repo variables

     

       252
       252
       +
       	if env["TANGLED_REPO_KNOT"] != "example.com" {

     

       253
       253
       +
       		t.Errorf("Expected TANGLED_REPO_KNOT='example.com', got '%s'", env["TANGLED_REPO_KNOT"])

     

       254
       254
       +
       	}

     

       255
       255
       +
       

     

       256
       256
       +
       	// Should not have ref/sha variables

     

       257
       257
       +
       	if _, ok := env["TANGLED_REF"]; ok {

     

       258
       258
       +
       		t.Error("Should not have TANGLED_REF when push data is nil")

     

       259
       259
       +
       	}

     

       260
       260
       +
       }

+15 -7

spindle/secrets/openbao.go

···

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
        
       type OpenBaoManager struct {

     

       16
       16
       -
       	client    *vault.Client

     

       17
       17
       -
       	mountPath string

     

       18
       18
       -
       	logger    *slog.Logger

     

       16
       16
       +
       	client            *vault.Client

     

       17
       17
       +
       	mountPath         string

     

       18
       18
       +
       	logger            *slog.Logger

     

       19
       19
       +
       	connectionTimeout time.Duration

     

       19
       20
        
       }

     

       20
       21
        
       

     

       21
       22
        
       type OpenBaoManagerOpt func(*OpenBaoManager)

     
···

       26
       27
        
       	}

     

       27
       28
        
       }

     

       28
       29
        
       

     

       30
       30
       +
       func WithConnectionTimeout(timeout time.Duration) OpenBaoManagerOpt {

     

       31
       31
       +
       	return func(v *OpenBaoManager) {

     

       32
       32
       +
       		v.connectionTimeout = timeout

     

       33
       33
       +
       	}

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       29
       36
        
       // NewOpenBaoManager creates a new OpenBao manager that connects to a Bao Proxy

     

       30
       37
        
       // The proxyAddress should point to the local Bao Proxy (e.g., "http://127.0.0.1:8200")

     

       31
       38
        
       // The proxy handles all authentication automatically via Auto-Auth

     
···

       43
       50
        
       	}

     

       44
       51
        
       

     

       45
       52
        
       	manager := &OpenBaoManager{

     

       46
       46
       -
       		client:    client,

     

       47
       47
       -
       		mountPath: "spindle", // default KV v2 mount path

     

       48
       48
       -
       		logger:    logger,

     

       53
       53
       +
       		client:            client,

     

       54
       54
       +
       		mountPath:         "spindle", // default KV v2 mount path

     

       55
       55
       +
       		logger:            logger,

     

       56
       56
       +
       		connectionTimeout: 10 * time.Second, // default connection timeout

     

       49
       57
        
       	}

     

       50
       58
        
       

     

       51
       59
        
       	for _, opt := range opts {

     
···

       62
       70
        
       

     

       63
       71
        
       // testConnection verifies that we can connect to the proxy

     

       64
       72
        
       func (v *OpenBaoManager) testConnection() error {

     

       65
       65
       -
       	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

     

       73
       73
       +
       	ctx, cancel := context.WithTimeout(context.Background(), v.connectionTimeout)

     

       66
       74
        
       	defer cancel()

     

       67
       75
        
       

     

       68
       76
        
       	// try token self-lookup as a quick way to verify proxy works

+5 -2

spindle/secrets/openbao_test.go

···

       152
       152
        
       	for _, tt := range tests {

     

       153
       153
        
       		t.Run(tt.name, func(t *testing.T) {

     

       154
       154
        
       			logger := slog.New(slog.NewTextHandler(os.Stderr, nil))

     

       155
       155
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, tt.opts...)

     

       155
       155
       +
       			// Use shorter timeout for tests to avoid long waits

     

       156
       156
       +
       			opts := append(tt.opts, WithConnectionTimeout(1*time.Second))

     

       157
       157
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, opts...)

     

       156
       158
        
       

     

       157
       159
        
       			if tt.expectError {

     

       158
       160
        
       				assert.Error(t, err)

     
···

       596
       598
        
       

     

       597
       599
        
       			// All these will fail because no real proxy is running

     

       598
       600
        
       			// but we can test that the configuration is properly accepted

     

       599
       599
       -
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger)

     

       601
       601
       +
       			// Use shorter timeout for tests to avoid long waits

     

       602
       602
       +
       			manager, err := NewOpenBaoManager(tt.proxyAddr, logger, WithConnectionTimeout(1*time.Second))

     

       600
       603
        
       			assert.Error(t, err) // Expected because no real proxy

     

       601
       604
        
       			assert.Nil(t, manager)

     

       602
       605
        
       			assert.Contains(t, err.Error(), "failed to connect to bao proxy")

+97 -41

spindle/server.go

···

       6
       6
        
       	"encoding/json"

     

       7
       7
        
       	"fmt"

     

       8
       8
        
       	"log/slog"

     

       9
       9
       +
       	"maps"

     

       9
       10
        
       	"net/http"

     

       10
       11
        
       

     

       11
       12
        
       	"github.com/go-chi/chi/v5"

     
···

       49
       50
        
       	vault secrets.Manager

     

       50
       51
        
       }

     

       51
       52
        
       

     

       52
       52
       -
       func Run(ctx context.Context) error {

     

       53
       53
       +
       // New creates a new Spindle server with the provided configuration and engines.

     

       54
       54
       +
       func New(ctx context.Context, cfg *config.Config, engines map[string]models.Engine) (*Spindle, error) {

     

       53
       55
        
       	logger := log.FromContext(ctx)

     

       54
       56
        
       

     

       55
       55
       -
       	cfg, err := config.Load(ctx)

     

       56
       56
       -
       	if err != nil {

     

       57
       57
       -
       		return fmt.Errorf("failed to load config: %w", err)

     

       58
       58
       -
       	}

     

       59
       59
       -
       

     

       60
       57
        
       	d, err := db.Make(cfg.Server.DBPath)

     

       61
       58
        
       	if err != nil {

     

       62
       62
       -
       		return fmt.Errorf("failed to setup db: %w", err)

     

       59
       59
       +
       		return nil, fmt.Errorf("failed to setup db: %w", err)

     

       63
       60
        
       	}

     

       64
       61
        
       

     

       65
       62
        
       	e, err := rbac.NewEnforcer(cfg.Server.DBPath)

     

       66
       63
        
       	if err != nil {

     

       67
       67
       -
       		return fmt.Errorf("failed to setup rbac enforcer: %w", err)

     

       64
       64
       +
       		return nil, fmt.Errorf("failed to setup rbac enforcer: %w", err)

     

       68
       65
        
       	}

     

       69
       66
        
       	e.E.EnableAutoSave(true)

     

       70
       67
        
       

     
···

       74
       71
        
       	switch cfg.Server.Secrets.Provider {

     

       75
       72
        
       	case "openbao":

     

       76
       73
        
       		if cfg.Server.Secrets.OpenBao.ProxyAddr == "" {

     

       77
       77
       -
       			return fmt.Errorf("openbao proxy address is required when using openbao secrets provider")

     

       74
       74
       +
       			return nil, fmt.Errorf("openbao proxy address is required when using openbao secrets provider")

     

       78
       75
        
       		}

     

       79
       76
        
       		vault, err = secrets.NewOpenBaoManager(

     

       80
       77
        
       			cfg.Server.Secrets.OpenBao.ProxyAddr,

     
···

       82
       79
        
       			secrets.WithMountPath(cfg.Server.Secrets.OpenBao.Mount),

     

       83
       80
        
       		)

     

       84
       81
        
       		if err != nil {

     

       85
       85
       -
       			return fmt.Errorf("failed to setup openbao secrets provider: %w", err)

     

       82
       82
       +
       			return nil, fmt.Errorf("failed to setup openbao secrets provider: %w", err)

     

       86
       83
        
       		}

     

       87
       84
        
       		logger.Info("using openbao secrets provider", "proxy_address", cfg.Server.Secrets.OpenBao.ProxyAddr, "mount", cfg.Server.Secrets.OpenBao.Mount)

     

       88
       85
        
       	case "sqlite", "":

     

       89
       86
        
       		vault, err = secrets.NewSQLiteManager(cfg.Server.DBPath, secrets.WithTableName("secrets"))

     

       90
       87
        
       		if err != nil {

     

       91
       91
       -
       			return fmt.Errorf("failed to setup sqlite secrets provider: %w", err)

     

       88
       88
       +
       			return nil, fmt.Errorf("failed to setup sqlite secrets provider: %w", err)

     

       92
       89
        
       		}

     

       93
       90
        
       		logger.Info("using sqlite secrets provider", "path", cfg.Server.DBPath)

     

       94
       91
        
       	default:

     

       95
       95
       -
       		return fmt.Errorf("unknown secrets provider: %s", cfg.Server.Secrets.Provider)

     

       96
       96
       -
       	}

     

       97
       97
       -
       

     

       98
       98
       -
       	nixeryEng, err := nixery.New(ctx, cfg)

     

       99
       99
       -
       	if err != nil {

     

       100
       100
       -
       		return err

     

       92
       92
       +
       		return nil, fmt.Errorf("unknown secrets provider: %s", cfg.Server.Secrets.Provider)

     

       101
       93
        
       	}

     

       102
       94
        
       

     

       103
       95
        
       	jq := queue.NewQueue(cfg.Server.QueueSize, cfg.Server.MaxJobCount)

     
···

       110
       102
        
       	}

     

       111
       103
        
       	jc, err := jetstream.NewJetstreamClient(cfg.Server.JetstreamEndpoint, "spindle", collections, nil, log.SubLogger(logger, "jetstream"), d, true, true)

     

       112
       104
        
       	if err != nil {

     

       113
       113
       -
       		return fmt.Errorf("failed to setup jetstream client: %w", err)

     

       105
       105
       +
       		return nil, fmt.Errorf("failed to setup jetstream client: %w", err)

     

       114
       106
        
       	}

     

       115
       107
        
       	jc.AddDid(cfg.Server.Owner)

     

       116
       108
        
       

     

       117
       109
        
       	// Check if the spindle knows about any Dids;

     

       118
       110
        
       	dids, err := d.GetAllDids()

     

       119
       111
        
       	if err != nil {

     

       120
       120
       -
       		return fmt.Errorf("failed to get all dids: %w", err)

     

       112
       112
       +
       		return nil, fmt.Errorf("failed to get all dids: %w", err)

     

       121
       113
        
       	}

     

       122
       114
        
       	for _, d := range dids {

     

       123
       115
        
       		jc.AddDid(d)

     

       124
       116
        
       	}

     

       125
       117
        
       

     

       126
       126
       -
       	resolver := idresolver.DefaultResolver()

     

       118
       118
       +
       	resolver := idresolver.DefaultResolver(cfg.Server.PlcUrl)

     

       127
       119
        
       

     

       128
       128
       -
       	spindle := Spindle{

     

       120
       120
       +
       	spindle := &Spindle{

     

       129
       121
        
       		jc:    jc,

     

       130
       122
        
       		e:     e,

     

       131
       123
        
       		db:    d,

     

       132
       124
        
       		l:     logger,

     

       133
       125
        
       		n:     &n,

     

       134
       134
       -
       		engs:  map[string]models.Engine{"nixery": nixeryEng},

     

       126
       126
       +
       		engs:  engines,

     

       135
       127
        
       		jq:    jq,

     

       136
       128
        
       		cfg:   cfg,

     

       137
       129
        
       		res:   resolver,

     
···

       140
       132
        
       

     

       141
       133
        
       	err = e.AddSpindle(rbacDomain)

     

       142
       134
        
       	if err != nil {

     

       143
       143
       -
       		return fmt.Errorf("failed to set rbac domain: %w", err)

     

       135
       135
       +
       		return nil, fmt.Errorf("failed to set rbac domain: %w", err)

     

       144
       136
        
       	}

     

       145
       137
        
       	err = spindle.configureOwner()

     

       146
       138
        
       	if err != nil {

     

       147
       147
       -
       		return err

     

       139
       139
       +
       		return nil, err

     

       148
       140
        
       	}

     

       149
       141
        
       	logger.Info("owner set", "did", cfg.Server.Owner)

     

       150
       142
        
       

     

       151
       151
       -
       	// starts a job queue runner in the background

     

       152
       152
       -
       	jq.Start()

     

       153
       153
       -
       	defer jq.Stop()

     

       154
       154
       -
       

     

       155
       155
       -
       	// Stop vault token renewal if it implements Stopper

     

       156
       156
       -
       	if stopper, ok := vault.(secrets.Stopper); ok {

     

       157
       157
       -
       		defer stopper.Stop()

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       143
        
       	cursorStore, err := cursor.NewSQLiteStore(cfg.Server.DBPath)

     

       161
       144
        
       	if err != nil {

     

       162
       162
       -
       		return fmt.Errorf("failed to setup sqlite3 cursor store: %w", err)

     

       145
       145
       +
       		return nil, fmt.Errorf("failed to setup sqlite3 cursor store: %w", err)

     

       163
       146
        
       	}

     

       164
       147
        
       

     

       165
       148
        
       	err = jc.StartJetstream(ctx, spindle.ingest())

     

       166
       149
        
       	if err != nil {

     

       167
       167
       -
       		return fmt.Errorf("failed to start jetstream consumer: %w", err)

     

       150
       150
       +
       		return nil, fmt.Errorf("failed to start jetstream consumer: %w", err)

     

       168
       151
        
       	}

     

       169
       152
        
       

     

       170
       153
        
       	// for each incoming sh.tangled.pipeline, we execute

     
···

       177
       160
        
       	ccfg.CursorStore = cursorStore

     

       178
       161
        
       	knownKnots, err := d.Knots()

     

       179
       162
        
       	if err != nil {

     

       180
       180
       -
       		return err

     

       163
       163
       +
       		return nil, err

     

       181
       164
        
       	}

     

       182
       165
        
       	for _, knot := range knownKnots {

     

       183
       166
        
       		logger.Info("adding source start", "knot", knot)

     
···

       185
       168
        
       	}

     

       186
       169
        
       	spindle.ks = eventconsumer.NewConsumer(*ccfg)

     

       187
       170
        
       

     

       171
       171
       +
       	return spindle, nil

     

       172
       172
       +
       }

     

       173
       173
       +
       

     

       174
       174
       +
       // DB returns the database instance.

     

       175
       175
       +
       func (s *Spindle) DB() *db.DB {

     

       176
       176
       +
       	return s.db

     

       177
       177
       +
       }

     

       178
       178
       +
       

     

       179
       179
       +
       // Queue returns the job queue instance.

     

       180
       180
       +
       func (s *Spindle) Queue() *queue.Queue {

     

       181
       181
       +
       	return s.jq

     

       182
       182
       +
       }

     

       183
       183
       +
       

     

       184
       184
       +
       // Engines returns the map of available engines.

     

       185
       185
       +
       func (s *Spindle) Engines() map[string]models.Engine {

     

       186
       186
       +
       	return s.engs

     

       187
       187
       +
       }

     

       188
       188
       +
       

     

       189
       189
       +
       // Vault returns the secrets manager instance.

     

       190
       190
       +
       func (s *Spindle) Vault() secrets.Manager {

     

       191
       191
       +
       	return s.vault

     

       192
       192
       +
       }

     

       193
       193
       +
       

     

       194
       194
       +
       // Notifier returns the notifier instance.

     

       195
       195
       +
       func (s *Spindle) Notifier() *notifier.Notifier {

     

       196
       196
       +
       	return s.n

     

       197
       197
       +
       }

     

       198
       198
       +
       

     

       199
       199
       +
       // Enforcer returns the RBAC enforcer instance.

     

       200
       200
       +
       func (s *Spindle) Enforcer() *rbac.Enforcer {

     

       201
       201
       +
       	return s.e

     

       202
       202
       +
       }

     

       203
       203
       +
       

     

       204
       204
       +
       // Start starts the Spindle server (blocking).

     

       205
       205
       +
       func (s *Spindle) Start(ctx context.Context) error {

     

       206
       206
       +
       	// starts a job queue runner in the background

     

       207
       207
       +
       	s.jq.Start()

     

       208
       208
       +
       	defer s.jq.Stop()

     

       209
       209
       +
       

     

       210
       210
       +
       	// Stop vault token renewal if it implements Stopper

     

       211
       211
       +
       	if stopper, ok := s.vault.(secrets.Stopper); ok {

     

       212
       212
       +
       		defer stopper.Stop()

     

       213
       213
       +
       	}

     

       214
       214
       +
       

     

       188
       215
        
       	go func() {

     

       189
       189
       -
       		logger.Info("starting knot event consumer")

     

       190
       190
       -
       		spindle.ks.Start(ctx)

     

       216
       216
       +
       		s.l.Info("starting knot event consumer")

     

       217
       217
       +
       		s.ks.Start(ctx)

     

       191
       218
        
       	}()

     

       192
       219
        
       

     

       193
       193
       -
       	logger.Info("starting spindle server", "address", cfg.Server.ListenAddr)

     

       194
       194
       -
       	logger.Error("server error", "error", http.ListenAndServe(cfg.Server.ListenAddr, spindle.Router()))

     

       220
       220
       +
       	s.l.Info("starting spindle server", "address", s.cfg.Server.ListenAddr)

     

       221
       221
       +
       	return http.ListenAndServe(s.cfg.Server.ListenAddr, s.Router())

     

       222
       222
       +
       }

     

       195
       223
        
       

     

       196
       196
       -
       	return nil

     

       224
       224
       +
       func Run(ctx context.Context) error {

     

       225
       225
       +
       	cfg, err := config.Load(ctx)

     

       226
       226
       +
       	if err != nil {

     

       227
       227
       +
       		return fmt.Errorf("failed to load config: %w", err)

     

       228
       228
       +
       	}

     

       229
       229
       +
       

     

       230
       230
       +
       	nixeryEng, err := nixery.New(ctx, cfg)

     

       231
       231
       +
       	if err != nil {

     

       232
       232
       +
       		return err

     

       233
       233
       +
       	}

     

       234
       234
       +
       

     

       235
       235
       +
       	s, err := New(ctx, cfg, map[string]models.Engine{

     

       236
       236
       +
       		"nixery": nixeryEng,

     

       237
       237
       +
       	})

     

       238
       238
       +
       	if err != nil {

     

       239
       239
       +
       		return err

     

       240
       240
       +
       	}

     

       241
       241
       +
       

     

       242
       242
       +
       	return s.Start(ctx)

     

       197
       243
        
       }

     

       198
       244
        
       

     

       199
       245
        
       func (s *Spindle) Router() http.Handler {

     
···

       266
       312
        
       

     

       267
       313
        
       		workflows := make(map[models.Engine][]models.Workflow)

     

       268
       314
        
       

     

       315
       315
       +
       		// Build pipeline environment variables once for all workflows

     

       316
       316
       +
       		pipelineEnv := models.PipelineEnvVars(tpl.TriggerMetadata, pipelineId, s.cfg.Server.Dev)

     

       317
       317
       +
       

     

       269
       318
        
       		for _, w := range tpl.Workflows {

     

       270
       319
        
       			if w != nil {

     

       271
       320
        
       				if _, ok := s.engs[w.Engine]; !ok {

     
···

       290
       339
        
       				if err != nil {

     

       291
       340
        
       					return err

     

       292
       341
        
       				}

     

       342
       342
       +
       

     

       343
       343
       +
       				// inject TANGLED_* env vars after InitWorkflow

     

       344
       344
       +
       				// This prevents user-defined env vars from overriding them

     

       345
       345
       +
       				if ewf.Environment == nil {

     

       346
       346
       +
       					ewf.Environment = make(map[string]string)

     

       347
       347
       +
       				}

     

       348
       348
       +
       				maps.Copy(ewf.Environment, pipelineEnv)

     

       293
       349
        
       

     

       294
       350
        
       				workflows[eng] = append(workflows[eng], *ewf)

     

       295
       351

spindle/stream.go

···

       213
       213
        
       			if err := conn.WriteMessage(websocket.TextMessage, []byte(line.Text)); err != nil {

     

       214
       214
        
       				return fmt.Errorf("failed to write to websocket: %w", err)

     

       215
       215
        
       			}

     

       216
       216
       +
       		case <-time.After(30 * time.Second):

     

       217
       217
       +
       			// send a keep-alive

     

       218
       218
       +
       			if err := conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil {

     

       219
       219
       +
       				return fmt.Errorf("failed to write control: %w", err)

     

       220
       220
       +
       			}

     

       216
       221
        
       		}

     

       217
       222
        
       	}

     

       218
       223
        
       }

+199

types/commit.go

···

       1
       1
       +
       package types

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"bytes"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"fmt"

     

       7
       7
       +
       	"maps"

     

       8
       8
       +
       	"regexp"

     

       9
       9
       +
       	"strings"

     

       10
       10
       +
       

     

       11
       11
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       12
       12
       +
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type Commit struct {

     

       16
       16
       +
       	// hash of the commit object.

     

       17
       17
       +
       	Hash plumbing.Hash `json:"hash,omitempty"`

     

       18
       18
       +
       

     

       19
       19
       +
       	// author is the original author of the commit.

     

       20
       20
       +
       	Author object.Signature `json:"author"`

     

       21
       21
       +
       

     

       22
       22
       +
       	// committer is the one performing the commit, might be different from author.

     

       23
       23
       +
       	Committer object.Signature `json:"committer"`

     

       24
       24
       +
       

     

       25
       25
       +
       	// message is the commit message, contains arbitrary text.

     

       26
       26
       +
       	Message string `json:"message"`

     

       27
       27
       +
       

     

       28
       28
       +
       	// treehash is the hash of the root tree of the commit.

     

       29
       29
       +
       	Tree string `json:"tree"`

     

       30
       30
       +
       

     

       31
       31
       +
       	// parents are the hashes of the parent commits of the commit.

     

       32
       32
       +
       	ParentHashes []plumbing.Hash `json:"parent_hashes,omitempty"`

     

       33
       33
       +
       

     

       34
       34
       +
       	// pgpsignature is the pgp signature of the commit.

     

       35
       35
       +
       	PGPSignature string `json:"pgp_signature,omitempty"`

     

       36
       36
       +
       

     

       37
       37
       +
       	// mergetag is the embedded tag object when a merge commit is created by

     

       38
       38
       +
       	// merging a signed tag.

     

       39
       39
       +
       	MergeTag string `json:"merge_tag,omitempty"`

     

       40
       40
       +
       

     

       41
       41
       +
       	// changeid is a unique identifier for the change (e.g., gerrit change-id).

     

       42
       42
       +
       	ChangeId string `json:"change_id,omitempty"`

     

       43
       43
       +
       

     

       44
       44
       +
       	// extraheaders contains additional headers not captured by other fields.

     

       45
       45
       +
       	ExtraHeaders map[string][]byte `json:"extra_headers,omitempty"`

     

       46
       46
       +
       

     

       47
       47
       +
       	// deprecated: kept for backwards compatibility with old json format.

     

       48
       48
       +
       	This string `json:"this,omitempty"`

     

       49
       49
       +
       

     

       50
       50
       +
       	// deprecated: kept for backwards compatibility with old json format.

     

       51
       51
       +
       	Parent string `json:"parent,omitempty"`

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       // types.Commit is an unify two commit structs:

     

       55
       55
       +
       //   - git.object.Commit from

     

       56
       56
       +
       //   - types.NiceDiff.commit

     

       57
       57
       +
       //

     

       58
       58
       +
       // to do this in backwards compatible fashion, we define the base struct

     

       59
       59
       +
       // to use the same fields as NiceDiff.Commit, and then we also unmarshal

     

       60
       60
       +
       // the struct fields from go-git structs, this custom unmarshal makes sense

     

       61
       61
       +
       // of both representations and unifies them to have maximal data in either

     

       62
       62
       +
       // form.

     

       63
       63
       +
       func (c *Commit) UnmarshalJSON(data []byte) error {

     

       64
       64
       +
       	type Alias Commit

     

       65
       65
       +
       

     

       66
       66
       +
       	aux := &struct {

     

       67
       67
       +
       		*object.Commit

     

       68
       68
       +
       		*Alias

     

       69
       69
       +
       	}{

     

       70
       70
       +
       		Alias: (*Alias)(c),

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	if err := json.Unmarshal(data, aux); err != nil {

     

       74
       74
       +
       		return err

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	c.FromGoGitCommit(aux.Commit)

     

       78
       78
       +
       

     

       79
       79
       +
       	return nil

     

       80
       80
       +
       }

     

       81
       81
       +
       

     

       82
       82
       +
       // fill in as much of Commit as possible from the given go-git commit

     

       83
       83
       +
       func (c *Commit) FromGoGitCommit(gc *object.Commit) {

     

       84
       84
       +
       	if gc == nil {

     

       85
       85
       +
       		return

     

       86
       86
       +
       	}

     

       87
       87
       +
       

     

       88
       88
       +
       	if c.Hash.IsZero() {

     

       89
       89
       +
       		c.Hash = gc.Hash

     

       90
       90
       +
       	}

     

       91
       91
       +
       	if c.This == "" {

     

       92
       92
       +
       		c.This = gc.Hash.String()

     

       93
       93
       +
       	}

     

       94
       94
       +
       	if isEmptySignature(c.Author) {

     

       95
       95
       +
       		c.Author = gc.Author

     

       96
       96
       +
       	}

     

       97
       97
       +
       	if isEmptySignature(c.Committer) {

     

       98
       98
       +
       		c.Committer = gc.Committer

     

       99
       99
       +
       	}

     

       100
       100
       +
       	if c.Message == "" {

     

       101
       101
       +
       		c.Message = gc.Message

     

       102
       102
       +
       	}

     

       103
       103
       +
       	if c.Tree == "" {

     

       104
       104
       +
       		c.Tree = gc.TreeHash.String()

     

       105
       105
       +
       	}

     

       106
       106
       +
       	if c.PGPSignature == "" {

     

       107
       107
       +
       		c.PGPSignature = gc.PGPSignature

     

       108
       108
       +
       	}

     

       109
       109
       +
       	if c.MergeTag == "" {

     

       110
       110
       +
       		c.MergeTag = gc.MergeTag

     

       111
       111
       +
       	}

     

       112
       112
       +
       

     

       113
       113
       +
       	if len(c.ParentHashes) == 0 {

     

       114
       114
       +
       		c.ParentHashes = gc.ParentHashes

     

       115
       115
       +
       	}

     

       116
       116
       +
       	if c.Parent == "" && len(gc.ParentHashes) > 0 {

     

       117
       117
       +
       		c.Parent = gc.ParentHashes[0].String()

     

       118
       118
       +
       	}

     

       119
       119
       +
       

     

       120
       120
       +
       	if len(c.ExtraHeaders) == 0 {

     

       121
       121
       +
       		c.ExtraHeaders = make(map[string][]byte)

     

       122
       122
       +
       		maps.Copy(c.ExtraHeaders, gc.ExtraHeaders)

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

       125
       125
       +
       	if c.ChangeId == "" {

     

       126
       126
       +
       		if v, ok := gc.ExtraHeaders["change-id"]; ok {

     

       127
       127
       +
       			c.ChangeId = string(v)

     

       128
       128
       +
       		}

     

       129
       129
       +
       	}

     

       130
       130
       +
       }

     

       131
       131
       +
       

     

       132
       132
       +
       func isEmptySignature(s object.Signature) bool {

     

       133
       133
       +
       	return s.Email == "" && s.Name == "" && s.When.IsZero()

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       // produce a verifiable payload from this commit's metadata

     

       137
       137
       +
       func (c *Commit) Payload() string {

     

       138
       138
       +
       	author := bytes.NewBuffer([]byte{})

     

       139
       139
       +
       	c.Author.Encode(author)

     

       140
       140
       +
       

     

       141
       141
       +
       	committer := bytes.NewBuffer([]byte{})

     

       142
       142
       +
       	c.Committer.Encode(committer)

     

       143
       143
       +
       

     

       144
       144
       +
       	payload := strings.Builder{}

     

       145
       145
       +
       

     

       146
       146
       +
       	fmt.Fprintf(&payload, "tree %s\n", c.Tree)

     

       147
       147
       +
       

     

       148
       148
       +
       	if len(c.ParentHashes) > 0 {

     

       149
       149
       +
       		for _, p := range c.ParentHashes {

     

       150
       150
       +
       			fmt.Fprintf(&payload, "parent %s\n", p.String())

     

       151
       151
       +
       		}

     

       152
       152
       +
       	} else {

     

       153
       153
       +
       		// present for backwards compatibility

     

       154
       154
       +
       		fmt.Fprintf(&payload, "parent %s\n", c.Parent)

     

       155
       155
       +
       	}

     

       156
       156
       +
       

     

       157
       157
       +
       	fmt.Fprintf(&payload, "author %s\n", author.String())

     

       158
       158
       +
       	fmt.Fprintf(&payload, "committer %s\n", committer.String())

     

       159
       159
       +
       

     

       160
       160
       +
       	if c.ChangeId != "" {

     

       161
       161
       +
       		fmt.Fprintf(&payload, "change-id %s\n", c.ChangeId)

     

       162
       162
       +
       	} else if v, ok := c.ExtraHeaders["change-id"]; ok {

     

       163
       163
       +
       		fmt.Fprintf(&payload, "change-id %s\n", string(v))

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	fmt.Fprintf(&payload, "\n%s", c.Message)

     

       167
       167
       +
       

     

       168
       168
       +
       	return payload.String()

     

       169
       169
       +
       }

     

       170
       170
       +
       

     

       171
       171
       +
       var (

     

       172
       172
       +
       	coAuthorRegex = regexp.MustCompile(`(?im)^Co-authored-by:\s*(.+?)\s*<([^>]+)>`)

     

       173
       173
       +
       )

     

       174
       174
       +
       

     

       175
       175
       +
       func (commit Commit) CoAuthors() []object.Signature {

     

       176
       176
       +
       	var coAuthors []object.Signature

     

       177
       177
       +
       	seen := make(map[string]bool)

     

       178
       178
       +
       	matches := coAuthorRegex.FindAllStringSubmatch(commit.Message, -1)

     

       179
       179
       +
       

     

       180
       180
       +
       	for _, match := range matches {

     

       181
       181
       +
       		if len(match) >= 3 {

     

       182
       182
       +
       			name := strings.TrimSpace(match[1])

     

       183
       183
       +
       			email := strings.TrimSpace(match[2])

     

       184
       184
       +
       

     

       185
       185
       +
       			if seen[email] {

     

       186
       186
       +
       				continue

     

       187
       187
       +
       			}

     

       188
       188
       +
       			seen[email] = true

     

       189
       189
       +
       

     

       190
       190
       +
       			coAuthors = append(coAuthors, object.Signature{

     

       191
       191
       +
       				Name:  name,

     

       192
       192
       +
       				Email: email,

     

       193
       193
       +
       				When:  commit.Committer.When,

     

       194
       194
       +
       			})

     

       195
       195
       +
       		}

     

       196
       196
       +
       	}

     

       197
       197
       +
       

     

       198
       198
       +
       	return coAuthors

     

       199
       199
       +
       }

+2 -12

types/diff.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

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

     

       5
       5
       -
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       6
       5
        
       )

     

       7
       6
        
       

     

       8
       7
        
       type DiffOpts struct {

     
···

       43
       42
        
       

     

       44
       43
        
       // A nicer git diff representation.

     

       45
       44
        
       type NiceDiff struct {

     

       46
       46
       -
       	Commit struct {

     

       47
       47
       -
       		Message      string           `json:"message"`

     

       48
       48
       -
       		Author       object.Signature `json:"author"`

     

       49
       49
       -
       		This         string           `json:"this"`

     

       50
       50
       -
       		Parent       string           `json:"parent"`

     

       51
       51
       -
       		PGPSignature string           `json:"pgp_signature"`

     

       52
       52
       -
       		Committer    object.Signature `json:"committer"`

     

       53
       53
       -
       		Tree         string           `json:"tree"`

     

       54
       54
       -
       		ChangedId    string           `json:"change_id"`

     

       55
       55
       -
       	} `json:"commit"`

     

       56
       56
       -
       	Stat struct {

     

       45
       45
       +
       	Commit Commit `json:"commit"`

     

       46
       46
       +
       	Stat   struct {

     

       57
       47
        
       		FilesChanged int `json:"files_changed"`

     

       58
       48
        
       		Insertions   int `json:"insertions"`

     

       59
       49
        
       		Deletions    int `json:"deletions"`

+39 -18

types/repo.go

···

       1
       1
        
       package types

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       

     

       4
       6
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       5
       7
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       6
       8
        
       )

     

       7
       9
        
       

     

       8
       10
        
       type RepoIndexResponse struct {

     

       9
       9
       -
       	IsEmpty        bool             `json:"is_empty"`

     

       10
       10
       -
       	Ref            string           `json:"ref,omitempty"`

     

       11
       11
       -
       	Readme         string           `json:"readme,omitempty"`

     

       12
       12
       -
       	ReadmeFileName string           `json:"readme_file_name,omitempty"`

     

       13
       13
       -
       	Commits        []*object.Commit `json:"commits,omitempty"`

     

       14
       14
       -
       	Description    string           `json:"description,omitempty"`

     

       15
       15
       -
       	Files          []NiceTree       `json:"files,omitempty"`

     

       16
       16
       -
       	Branches       []Branch         `json:"branches,omitempty"`

     

       17
       17
       -
       	Tags           []*TagReference  `json:"tags,omitempty"`

     

       18
       18
       -
       	TotalCommits   int              `json:"total_commits,omitempty"`

     

       11
       11
       +
       	IsEmpty        bool            `json:"is_empty"`

     

       12
       12
       +
       	Ref            string          `json:"ref,omitempty"`

     

       13
       13
       +
       	Readme         string          `json:"readme,omitempty"`

     

       14
       14
       +
       	ReadmeFileName string          `json:"readme_file_name,omitempty"`

     

       15
       15
       +
       	Commits        []Commit        `json:"commits,omitempty"`

     

       16
       16
       +
       	Description    string          `json:"description,omitempty"`

     

       17
       17
       +
       	Files          []NiceTree      `json:"files,omitempty"`

     

       18
       18
       +
       	Branches       []Branch        `json:"branches,omitempty"`

     

       19
       19
       +
       	Tags           []*TagReference `json:"tags,omitempty"`

     

       20
       20
       +
       	TotalCommits   int             `json:"total_commits,omitempty"`

     

       19
       21
        
       }

     

       20
       22
        
       

     

       21
       23
        
       type RepoLogResponse struct {

     

       22
       22
       -
       	Commits     []*object.Commit `json:"commits,omitempty"`

     

       23
       23
       -
       	Ref         string           `json:"ref,omitempty"`

     

       24
       24
       -
       	Description string           `json:"description,omitempty"`

     

       25
       25
       -
       	Log         bool             `json:"log,omitempty"`

     

       26
       26
       -
       	Total       int              `json:"total,omitempty"`

     

       27
       27
       -
       	Page        int              `json:"page,omitempty"`

     

       28
       28
       -
       	PerPage     int              `json:"per_page,omitempty"`

     

       24
       24
       +
       	Commits     []Commit `json:"commits,omitempty"`

     

       25
       25
       +
       	Ref         string   `json:"ref,omitempty"`

     

       26
       26
       +
       	Description string   `json:"description,omitempty"`

     

       27
       27
       +
       	Log         bool     `json:"log,omitempty"`

     

       28
       28
       +
       	Total       int      `json:"total,omitempty"`

     

       29
       29
       +
       	Page        int      `json:"page,omitempty"`

     

       30
       30
       +
       	PerPage     int      `json:"per_page,omitempty"`

     

       29
       31
        
       }

     

       30
       32
        
       

     

       31
       33
        
       type RepoCommitResponse struct {

     
···

       66
       68
        
       type Branch struct {

     

       67
       69
        
       	Reference `json:"reference"`

     

       68
       70
        
       	Commit    *object.Commit `json:"commit,omitempty"`

     

       69
       69
       -
       	IsDefault bool           `json:"is_deafult,omitempty"`

     

       71
       71
       +
       	IsDefault bool           `json:"is_default,omitempty"`

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       func (b *Branch) UnmarshalJSON(data []byte) error {

     

       75
       75
       +
       	aux := &struct {

     

       76
       76
       +
       		Reference          `json:"reference"`

     

       77
       77
       +
       		Commit             *object.Commit `json:"commit,omitempty"`

     

       78
       78
       +
       		IsDefault          bool           `json:"is_default,omitempty"`

     

       79
       79
       +
       		MispelledIsDefault bool           `json:"is_deafult,omitempty"` // mispelled name

     

       80
       80
       +
       	}{}

     

       81
       81
       +
       

     

       82
       82
       +
       	if err := json.Unmarshal(data, aux); err != nil {

     

       83
       83
       +
       		return err

     

       84
       84
       +
       	}

     

       85
       85
       +
       

     

       86
       86
       +
       	b.Reference = aux.Reference

     

       87
       87
       +
       	b.Commit = aux.Commit

     

       88
       88
       +
       	b.IsDefault = aux.IsDefault || aux.MispelledIsDefault // whichever was set

     

       89
       89
       +
       

     

       90
       90
       +
       	return nil

     

       70
       91
        
       }

     

       71
       92
        
       

     

       72
       93
        
       type RepoTagsResponse struct {

+88 -5

types/tree.go

···

       1
       1
        
       package types

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"os"

     

       4
       6
        
       	"time"

     

       5
       7
        
       

     

       6
       8
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       9
       +
       	"github.com/go-git/go-git/v5/plumbing/filemode"

     

       7
       10
        
       )

     

       8
       11
        
       

     

       9
       12
        
       // A nicer git tree representation.

     

       10
       13
        
       type NiceTree struct {

     

       11
       14
        
       	// Relative path

     

       12
       12
       -
       	Name      string `json:"name"`

     

       13
       13
       -
       	Mode      string `json:"mode"`

     

       14
       14
       -
       	Size      int64  `json:"size"`

     

       15
       15
       -
       	IsFile    bool   `json:"is_file"`

     

       16
       16
       -
       	IsSubtree bool   `json:"is_subtree"`

     

       15
       15
       +
       	Name string `json:"name"`

     

       16
       16
       +
       	Mode string `json:"mode"`

     

       17
       17
       +
       	Size int64  `json:"size"`

     

       17
       18
        
       

     

       18
       19
        
       	LastCommit *LastCommitInfo `json:"last_commit,omitempty"`

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func (t *NiceTree) FileMode() (filemode.FileMode, error) {

     

       23
       23
       +
       	if numericMode, err := filemode.New(t.Mode); err == nil {

     

       24
       24
       +
       		return numericMode, nil

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

       27
       27
       +
       	// TODO: this is here for backwards compat, can be removed in future versions

     

       28
       28
       +
       	osMode, err := parseModeString(t.Mode)

     

       29
       29
       +
       	if err != nil {

     

       30
       30
       +
       		return filemode.Empty, nil

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	conv, err := filemode.NewFromOSFileMode(osMode)

     

       34
       34
       +
       	if err != nil {

     

       35
       35
       +
       		return filemode.Empty, nil

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	return conv, nil

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       // ParseFileModeString parses a file mode string like "-rw-r--r--"

     

       42
       42
       +
       // and returns an os.FileMode

     

       43
       43
       +
       func parseModeString(modeStr string) (os.FileMode, error) {

     

       44
       44
       +
       	if len(modeStr) != 10 {

     

       45
       45
       +
       		return 0, fmt.Errorf("invalid mode string length: expected 10, got %d", len(modeStr))

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	var mode os.FileMode

     

       49
       49
       +
       

     

       50
       50
       +
       	// Parse file type (first character)

     

       51
       51
       +
       	switch modeStr[0] {

     

       52
       52
       +
       	case 'd':

     

       53
       53
       +
       		mode |= os.ModeDir

     

       54
       54
       +
       	case 'l':

     

       55
       55
       +
       		mode |= os.ModeSymlink

     

       56
       56
       +
       	case '-':

     

       57
       57
       +
       		// regular file

     

       58
       58
       +
       	default:

     

       59
       59
       +
       		return 0, fmt.Errorf("unknown file type: %c", modeStr[0])

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	// parse permissions for owner, group, and other

     

       63
       63
       +
       	perms := modeStr[1:]

     

       64
       64
       +
       	shifts := []int{6, 3, 0} // bit shifts for owner, group, other

     

       65
       65
       +
       

     

       66
       66
       +
       	for i := range 3 {

     

       67
       67
       +
       		offset := i * 3

     

       68
       68
       +
       		shift := shifts[i]

     

       69
       69
       +
       

     

       70
       70
       +
       		if perms[offset] == 'r' {

     

       71
       71
       +
       			mode |= os.FileMode(4 << shift)

     

       72
       72
       +
       		}

     

       73
       73
       +
       		if perms[offset+1] == 'w' {

     

       74
       74
       +
       			mode |= os.FileMode(2 << shift)

     

       75
       75
       +
       		}

     

       76
       76
       +
       		if perms[offset+2] == 'x' {

     

       77
       77
       +
       			mode |= os.FileMode(1 << shift)

     

       78
       78
       +
       		}

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	return mode, nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (t *NiceTree) IsFile() bool {

     

       85
       85
       +
       	m, err := t.FileMode()

     

       86
       86
       +
       

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return false

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	return m.IsFile()

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       func (t *NiceTree) IsSubmodule() bool {

     

       95
       95
       +
       	m, err := t.FileMode()

     

       96
       96
       +
       

     

       97
       97
       +
       	if err != nil {

     

       98
       98
       +
       		return false

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	return m == filemode.Submodule

     

       19
       102
        
       }

     

       20
       103
        
       

     

       21
       104
        
       type LastCommitInfo struct {

+9 -1

workflow/compile.go

···

       113
       113
        
       func (compiler *Compiler) compileWorkflow(w Workflow) *tangled.Pipeline_Workflow {

     

       114
       114
        
       	cw := &tangled.Pipeline_Workflow{}

     

       115
       115
        
       

     

       116
       116
       -
       	if !w.Match(compiler.Trigger) {

     

       116
       116
       +
       	matched, err := w.Match(compiler.Trigger)

     

       117
       117
       +
       	if err != nil {

     

       118
       118
       +
       		compiler.Diagnostics.AddError(

     

       119
       119
       +
       			w.Name,

     

       120
       120
       +
       			fmt.Errorf("failed to execute workflow: %w", err),

     

       121
       121
       +
       		)

     

       122
       122
       +
       		return nil

     

       123
       123
       +
       	}

     

       124
       124
       +
       	if !matched {

     

       117
       125
        
       		compiler.Diagnostics.AddWarning(

     

       118
       126
        
       			w.Name,

     

       119
       127
        
       			WorkflowSkipped,

+125

workflow/compile_test.go

···

       95
       95
        
       	assert.Len(t, c.Diagnostics.Errors, 1)

     

       96
       96
        
       	assert.Equal(t, MissingEngine, c.Diagnostics.Errors[0].Error)

     

       97
       97
        
       }

     

       98
       98
       +
       

     

       99
       99
       +
       func TestCompileWorkflow_MultipleBranchAndTag(t *testing.T) {

     

       100
       100
       +
       	wf := Workflow{

     

       101
       101
       +
       		Name: ".tangled/workflows/branch_and_tag.yml",

     

       102
       102
       +
       		When: []Constraint{

     

       103
       103
       +
       			{

     

       104
       104
       +
       				Event:  []string{"push"},

     

       105
       105
       +
       				Branch: []string{"main", "develop"},

     

       106
       106
       +
       				Tag:    []string{"v*"},

     

       107
       107
       +
       			},

     

       108
       108
       +
       		},

     

       109
       109
       +
       		Engine: "nixery",

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	tests := []struct {

     

       113
       113
       +
       		name          string

     

       114
       114
       +
       		trigger       tangled.Pipeline_TriggerMetadata

     

       115
       115
       +
       		shouldMatch   bool

     

       116
       116
       +
       		expectedCount int

     

       117
       117
       +
       	}{

     

       118
       118
       +
       		{

     

       119
       119
       +
       			name: "matches main branch",

     

       120
       120
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       121
       121
       +
       				Kind: string(TriggerKindPush),

     

       122
       122
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       123
       123
       +
       					Ref:    "refs/heads/main",

     

       124
       124
       +
       					OldSha: strings.Repeat("0", 40),

     

       125
       125
       +
       					NewSha: strings.Repeat("f", 40),

     

       126
       126
       +
       				},

     

       127
       127
       +
       			},

     

       128
       128
       +
       			shouldMatch:   true,

     

       129
       129
       +
       			expectedCount: 1,

     

       130
       130
       +
       		},

     

       131
       131
       +
       		{

     

       132
       132
       +
       			name: "matches develop branch",

     

       133
       133
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       134
       134
       +
       				Kind: string(TriggerKindPush),

     

       135
       135
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       136
       136
       +
       					Ref:    "refs/heads/develop",

     

       137
       137
       +
       					OldSha: strings.Repeat("0", 40),

     

       138
       138
       +
       					NewSha: strings.Repeat("f", 40),

     

       139
       139
       +
       				},

     

       140
       140
       +
       			},

     

       141
       141
       +
       			shouldMatch:   true,

     

       142
       142
       +
       			expectedCount: 1,

     

       143
       143
       +
       		},

     

       144
       144
       +
       		{

     

       145
       145
       +
       			name: "matches v* tag pattern",

     

       146
       146
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       147
       147
       +
       				Kind: string(TriggerKindPush),

     

       148
       148
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       149
       149
       +
       					Ref:    "refs/tags/v1.0.0",

     

       150
       150
       +
       					OldSha: strings.Repeat("0", 40),

     

       151
       151
       +
       					NewSha: strings.Repeat("f", 40),

     

       152
       152
       +
       				},

     

       153
       153
       +
       			},

     

       154
       154
       +
       			shouldMatch:   true,

     

       155
       155
       +
       			expectedCount: 1,

     

       156
       156
       +
       		},

     

       157
       157
       +
       		{

     

       158
       158
       +
       			name: "matches v* tag pattern with different version",

     

       159
       159
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       160
       160
       +
       				Kind: string(TriggerKindPush),

     

       161
       161
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       162
       162
       +
       					Ref:    "refs/tags/v2.5.3",

     

       163
       163
       +
       					OldSha: strings.Repeat("0", 40),

     

       164
       164
       +
       					NewSha: strings.Repeat("f", 40),

     

       165
       165
       +
       				},

     

       166
       166
       +
       			},

     

       167
       167
       +
       			shouldMatch:   true,

     

       168
       168
       +
       			expectedCount: 1,

     

       169
       169
       +
       		},

     

       170
       170
       +
       		{

     

       171
       171
       +
       			name: "does not match master branch",

     

       172
       172
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       173
       173
       +
       				Kind: string(TriggerKindPush),

     

       174
       174
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       175
       175
       +
       					Ref:    "refs/heads/master",

     

       176
       176
       +
       					OldSha: strings.Repeat("0", 40),

     

       177
       177
       +
       					NewSha: strings.Repeat("f", 40),

     

       178
       178
       +
       				},

     

       179
       179
       +
       			},

     

       180
       180
       +
       			shouldMatch:   false,

     

       181
       181
       +
       			expectedCount: 0,

     

       182
       182
       +
       		},

     

       183
       183
       +
       		{

     

       184
       184
       +
       			name: "does not match non-v tag",

     

       185
       185
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       186
       186
       +
       				Kind: string(TriggerKindPush),

     

       187
       187
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       188
       188
       +
       					Ref:    "refs/tags/release-1.0",

     

       189
       189
       +
       					OldSha: strings.Repeat("0", 40),

     

       190
       190
       +
       					NewSha: strings.Repeat("f", 40),

     

       191
       191
       +
       				},

     

       192
       192
       +
       			},

     

       193
       193
       +
       			shouldMatch:   false,

     

       194
       194
       +
       			expectedCount: 0,

     

       195
       195
       +
       		},

     

       196
       196
       +
       		{

     

       197
       197
       +
       			name: "does not match feature branch",

     

       198
       198
       +
       			trigger: tangled.Pipeline_TriggerMetadata{

     

       199
       199
       +
       				Kind: string(TriggerKindPush),

     

       200
       200
       +
       				Push: &tangled.Pipeline_PushTriggerData{

     

       201
       201
       +
       					Ref:    "refs/heads/feature/new-feature",

     

       202
       202
       +
       					OldSha: strings.Repeat("0", 40),

     

       203
       203
       +
       					NewSha: strings.Repeat("f", 40),

     

       204
       204
       +
       				},

     

       205
       205
       +
       			},

     

       206
       206
       +
       			shouldMatch:   false,

     

       207
       207
       +
       			expectedCount: 0,

     

       208
       208
       +
       		},

     

       209
       209
       +
       	}

     

       210
       210
       +
       

     

       211
       211
       +
       	for _, tt := range tests {

     

       212
       212
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       213
       213
       +
       			c := Compiler{Trigger: tt.trigger}

     

       214
       214
       +
       			cp := c.Compile([]Workflow{wf})

     

       215
       215
       +
       

     

       216
       216
       +
       			assert.Len(t, cp.Workflows, tt.expectedCount)

     

       217
       217
       +
       			if tt.shouldMatch {

     

       218
       218
       +
       				assert.Equal(t, wf.Name, cp.Workflows[0].Name)

     

       219
       219
       +
       			}

     

       220
       220
       +
       		})

     

       221
       221
       +
       	}

     

       222
       222
       +
       }

+61 -19

workflow/def.go

···

       8
       8
        
       

     

       9
       9
        
       	"tangled.org/core/api/tangled"

     

       10
       10
        
       

     

       11
       11
       +
       	"github.com/bmatcuk/doublestar/v4"

     

       11
       12
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       12
       13
        
       	"gopkg.in/yaml.v3"

     

       13
       14
        
       )

     
···

       33
       34
        
       

     

       34
       35
        
       	Constraint struct {

     

       35
       36
        
       		Event  StringList `yaml:"event"`

     

       36
       36
       -
       		Branch StringList `yaml:"branch"` // this is optional, and only applied on "push" events

     

       37
       37
       +
       		Branch StringList `yaml:"branch"` // required for pull_request; for push, either branch or tag must be specified

     

       38
       38
       +
       		Tag    StringList `yaml:"tag"`    // optional; only applies to push events

     

       37
       39
        
       	}

     

       38
       40
        
       

     

       39
       41
        
       	CloneOpts struct {

     
···

       59
       61
        
       	return strings.ReplaceAll(string(t), "_", " ")

     

       60
       62
        
       }

     

       61
       63
        
       

     

       64
       64
       +
       // matchesPattern checks if a name matches any of the given patterns.

     

       65
       65
       +
       // Patterns can be exact matches or glob patterns using * and **.

     

       66
       66
       +
       // * matches any sequence of non-separator characters

     

       67
       67
       +
       // ** matches any sequence of characters including separators

     

       68
       68
       +
       func matchesPattern(name string, patterns []string) (bool, error) {

     

       69
       69
       +
       	for _, pattern := range patterns {

     

       70
       70
       +
       		matched, err := doublestar.Match(pattern, name)

     

       71
       71
       +
       		if err != nil {

     

       72
       72
       +
       			return false, err

     

       73
       73
       +
       		}

     

       74
       74
       +
       		if matched {

     

       75
       75
       +
       			return true, nil

     

       76
       76
       +
       		}

     

       77
       77
       +
       	}

     

       78
       78
       +
       	return false, nil

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       62
       81
        
       func FromFile(name string, contents []byte) (Workflow, error) {

     

       63
       82
        
       	var wf Workflow

     

       64
       83
        
       

     
···

       74
       93
        
       }

     

       75
       94
        
       

     

       76
       95
        
       // if any of the constraints on a workflow is true, return true

     

       77
       77
       -
       func (w *Workflow) Match(trigger tangled.Pipeline_TriggerMetadata) bool {

     

       96
       96
       +
       func (w *Workflow) Match(trigger tangled.Pipeline_TriggerMetadata) (bool, error) {

     

       78
       97
        
       	// manual triggers always run the workflow

     

       79
       98
        
       	if trigger.Manual != nil {

     

       80
       80
       -
       		return true

     

       99
       99
       +
       		return true, nil

     

       81
       100
        
       	}

     

       82
       101
        
       

     

       83
       102
        
       	// if not manual, run through the constraint list and see if any one matches

     

       84
       103
        
       	for _, c := range w.When {

     

       85
       85
       -
       		if c.Match(trigger) {

     

       86
       86
       -
       			return true

     

       104
       104
       +
       		matched, err := c.Match(trigger)

     

       105
       105
       +
       		if err != nil {

     

       106
       106
       +
       			return false, err

     

       107
       107
       +
       		}

     

       108
       108
       +
       		if matched {

     

       109
       109
       +
       			return true, nil

     

       87
       110
        
       		}

     

       88
       111
        
       	}

     

       89
       112
        
       

     

       90
       113
        
       	// no constraints, always run this workflow

     

       91
       114
        
       	if len(w.When) == 0 {

     

       92
       92
       -
       		return true

     

       115
       115
       +
       		return true, nil

     

       93
       116
        
       	}

     

       94
       117
        
       

     

       95
       95
       -
       	return false

     

       118
       118
       +
       	return false, nil

     

       96
       119
        
       }

     

       97
       120
        
       

     

       98
       98
       -
       func (c *Constraint) Match(trigger tangled.Pipeline_TriggerMetadata) bool {

     

       121
       121
       +
       func (c *Constraint) Match(trigger tangled.Pipeline_TriggerMetadata) (bool, error) {

     

       99
       122
        
       	match := true

     

       100
       123
        
       

     

       101
       124
        
       	// manual triggers always pass this constraint

     

       102
       125
        
       	if trigger.Manual != nil {

     

       103
       103
       -
       		return true

     

       126
       126
       +
       		return true, nil

     

       104
       127
        
       	}

     

       105
       128
        
       

     

       106
       129
        
       	// apply event constraints

     
···

       108
       131
        
       

     

       109
       132
        
       	// apply branch constraints for PRs

     

       110
       133
        
       	if trigger.PullRequest != nil {

     

       111
       111
       -
       		match = match && c.MatchBranch(trigger.PullRequest.TargetBranch)

     

       134
       134
       +
       		matched, err := c.MatchBranch(trigger.PullRequest.TargetBranch)

     

       135
       135
       +
       		if err != nil {

     

       136
       136
       +
       			return false, err

     

       137
       137
       +
       		}

     

       138
       138
       +
       		match = match && matched

     

       112
       139
        
       	}

     

       113
       140
        
       

     

       114
       141
        
       	// apply ref constraints for pushes

     

       115
       142
        
       	if trigger.Push != nil {

     

       116
       116
       -
       		match = match && c.MatchRef(trigger.Push.Ref)

     

       143
       143
       +
       		matched, err := c.MatchRef(trigger.Push.Ref)

     

       144
       144
       +
       		if err != nil {

     

       145
       145
       +
       			return false, err

     

       146
       146
       +
       		}

     

       147
       147
       +
       		match = match && matched

     

       117
       148
        
       	}

     

       118
       149
        
       

     

       119
       119
       -
       	return match

     

       120
       120
       -
       }

     

       121
       121
       -
       

     

       122
       122
       -
       func (c *Constraint) MatchBranch(branch string) bool {

     

       123
       123
       -
       	return slices.Contains(c.Branch, branch)

     

       150
       150
       +
       	return match, nil

     

       124
       151
        
       }

     

       125
       152
        
       

     

       126
       126
       -
       func (c *Constraint) MatchRef(ref string) bool {

     

       153
       153
       +
       func (c *Constraint) MatchRef(ref string) (bool, error) {

     

       127
       154
        
       	refName := plumbing.ReferenceName(ref)

     

       155
       155
       +
       	shortName := refName.Short()

     

       156
       156
       +
       

     

       128
       157
        
       	if refName.IsBranch() {

     

       129
       129
       -
       		return slices.Contains(c.Branch, refName.Short())

     

       158
       158
       +
       		return c.MatchBranch(shortName)

     

       130
       159
        
       	}

     

       131
       131
       -
       	return false

     

       160
       160
       +
       

     

       161
       161
       +
       	if refName.IsTag() {

     

       162
       162
       +
       		return c.MatchTag(shortName)

     

       163
       163
       +
       	}

     

       164
       164
       +
       

     

       165
       165
       +
       	return false, nil

     

       166
       166
       +
       }

     

       167
       167
       +
       

     

       168
       168
       +
       func (c *Constraint) MatchBranch(branch string) (bool, error) {

     

       169
       169
       +
       	return matchesPattern(branch, c.Branch)

     

       170
       170
       +
       }

     

       171
       171
       +
       

     

       172
       172
       +
       func (c *Constraint) MatchTag(tag string) (bool, error) {

     

       173
       173
       +
       	return matchesPattern(tag, c.Tag)

     

       132
       174
        
       }

     

       133
       175
        
       

     

       134
       176
        
       func (c *Constraint) MatchEvent(event string) bool {

+284 -1

workflow/def_test.go

···

       6
       6
        
       	"github.com/stretchr/testify/assert"

     

       7
       7
        
       )

     

       8
       8
        
       

     

       9
       9
       -
       func TestUnmarshalWorkflow(t *testing.T) {

     

       9
       9
       +
       func TestUnmarshalWorkflowWithBranch(t *testing.T) {

     

       10
       10
        
       	yamlData := `

     

       11
       11
        
       when:

     

       12
       12
        
         - event: ["push", "pull_request"]

     
···

       38
       38
        
       

     

       39
       39
        
       	assert.True(t, wf.CloneOpts.Skip, "Skip should be false")

     

       40
       40
        
       }

     

       41
       41
       +
       

     

       42
       42
       +
       func TestUnmarshalWorkflowWithTags(t *testing.T) {

     

       43
       43
       +
       	yamlData := `

     

       44
       44
       +
       when:

     

       45
       45
       +
         - event: ["push"]

     

       46
       46
       +
           tag: ["v*", "release-*"]`

     

       47
       47
       +
       

     

       48
       48
       +
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       49
       49
       +
       	assert.NoError(t, err, "YAML should unmarshal without error")

     

       50
       50
       +
       

     

       51
       51
       +
       	assert.Len(t, wf.When, 1, "Should have one constraint")

     

       52
       52
       +
       	assert.ElementsMatch(t, []string{"v*", "release-*"}, wf.When[0].Tag)

     

       53
       53
       +
       	assert.ElementsMatch(t, []string{"push"}, wf.When[0].Event)

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       func TestUnmarshalWorkflowWithBranchAndTag(t *testing.T) {

     

       57
       57
       +
       	yamlData := `

     

       58
       58
       +
       when:

     

       59
       59
       +
         - event: ["push"]

     

       60
       60
       +
           branch: ["main", "develop"]

     

       61
       61
       +
           tag: ["v*"]`

     

       62
       62
       +
       

     

       63
       63
       +
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       64
       64
       +
       	assert.NoError(t, err, "YAML should unmarshal without error")

     

       65
       65
       +
       

     

       66
       66
       +
       	assert.Len(t, wf.When, 1, "Should have one constraint")

     

       67
       67
       +
       	assert.ElementsMatch(t, []string{"main", "develop"}, wf.When[0].Branch)

     

       68
       68
       +
       	assert.ElementsMatch(t, []string{"v*"}, wf.When[0].Tag)

     

       69
       69
       +
       }

     

       70
       70
       +
       

     

       71
       71
       +
       func TestMatchesPattern(t *testing.T) {

     

       72
       72
       +
       	tests := []struct {

     

       73
       73
       +
       		name     string

     

       74
       74
       +
       		input    string

     

       75
       75
       +
       		patterns []string

     

       76
       76
       +
       		expected bool

     

       77
       77
       +
       	}{

     

       78
       78
       +
       		{"exact match", "main", []string{"main"}, true},

     

       79
       79
       +
       		{"exact match in list", "develop", []string{"main", "develop"}, true},

     

       80
       80
       +
       		{"no match", "feature", []string{"main", "develop"}, false},

     

       81
       81
       +
       		{"wildcard prefix", "v1.0.0", []string{"v*"}, true},

     

       82
       82
       +
       		{"wildcard suffix", "release-1.0", []string{"*-1.0"}, true},

     

       83
       83
       +
       		{"wildcard middle", "feature-123-test", []string{"feature-*-test"}, true},

     

       84
       84
       +
       		{"double star prefix", "release-1.0.0", []string{"release-**"}, true},

     

       85
       85
       +
       		{"double star with slashes", "release/1.0/hotfix", []string{"release/**"}, true},

     

       86
       86
       +
       		{"double star matches multiple levels", "foo/bar/baz/qux", []string{"foo/**"}, true},

     

       87
       87
       +
       		{"double star no match", "feature/test", []string{"release/**"}, false},

     

       88
       88
       +
       		{"no patterns matches nothing", "anything", []string{}, false},

     

       89
       89
       +
       		{"pattern doesn't match", "v1.0.0", []string{"release-*"}, false},

     

       90
       90
       +
       		{"complex pattern", "release/v1.2.3", []string{"release/*"}, true},

     

       91
       91
       +
       		{"single star stops at slash", "release/1.0/hotfix", []string{"release/*"}, false},

     

       92
       92
       +
       	}

     

       93
       93
       +
       

     

       94
       94
       +
       	for _, tt := range tests {

     

       95
       95
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       96
       96
       +
       			result, _ := matchesPattern(tt.input, tt.patterns)

     

       97
       97
       +
       			assert.Equal(t, tt.expected, result, "matchesPattern(%q, %v) should be %v", tt.input, tt.patterns, tt.expected)

     

       98
       98
       +
       		})

     

       99
       99
       +
       	}

     

       100
       100
       +
       }

     

       101
       101
       +
       

     

       102
       102
       +
       func TestConstraintMatchRef_Branches(t *testing.T) {

     

       103
       103
       +
       	tests := []struct {

     

       104
       104
       +
       		name       string

     

       105
       105
       +
       		constraint Constraint

     

       106
       106
       +
       		ref        string

     

       107
       107
       +
       		expected   bool

     

       108
       108
       +
       	}{

     

       109
       109
       +
       		{

     

       110
       110
       +
       			name:       "exact branch match",

     

       111
       111
       +
       			constraint: Constraint{Branch: []string{"main"}},

     

       112
       112
       +
       			ref:        "refs/heads/main",

     

       113
       113
       +
       			expected:   true,

     

       114
       114
       +
       		},

     

       115
       115
       +
       		{

     

       116
       116
       +
       			name:       "branch glob match",

     

       117
       117
       +
       			constraint: Constraint{Branch: []string{"feature-*"}},

     

       118
       118
       +
       			ref:        "refs/heads/feature-123",

     

       119
       119
       +
       			expected:   true,

     

       120
       120
       +
       		},

     

       121
       121
       +
       		{

     

       122
       122
       +
       			name:       "branch no match",

     

       123
       123
       +
       			constraint: Constraint{Branch: []string{"main"}},

     

       124
       124
       +
       			ref:        "refs/heads/develop",

     

       125
       125
       +
       			expected:   false,

     

       126
       126
       +
       		},

     

       127
       127
       +
       		{

     

       128
       128
       +
       			name:       "no constraints matches nothing",

     

       129
       129
       +
       			constraint: Constraint{},

     

       130
       130
       +
       			ref:        "refs/heads/anything",

     

       131
       131
       +
       			expected:   false,

     

       132
       132
       +
       		},

     

       133
       133
       +
       	}

     

       134
       134
       +
       

     

       135
       135
       +
       	for _, tt := range tests {

     

       136
       136
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       137
       137
       +
       			result, _ := tt.constraint.MatchRef(tt.ref)

     

       138
       138
       +
       			assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref)

     

       139
       139
       +
       		})

     

       140
       140
       +
       	}

     

       141
       141
       +
       }

     

       142
       142
       +
       

     

       143
       143
       +
       func TestConstraintMatchRef_Tags(t *testing.T) {

     

       144
       144
       +
       	tests := []struct {

     

       145
       145
       +
       		name       string

     

       146
       146
       +
       		constraint Constraint

     

       147
       147
       +
       		ref        string

     

       148
       148
       +
       		expected   bool

     

       149
       149
       +
       	}{

     

       150
       150
       +
       		{

     

       151
       151
       +
       			name:       "exact tag match",

     

       152
       152
       +
       			constraint: Constraint{Tag: []string{"v1.0.0"}},

     

       153
       153
       +
       			ref:        "refs/tags/v1.0.0",

     

       154
       154
       +
       			expected:   true,

     

       155
       155
       +
       		},

     

       156
       156
       +
       		{

     

       157
       157
       +
       			name:       "tag glob match",

     

       158
       158
       +
       			constraint: Constraint{Tag: []string{"v*"}},

     

       159
       159
       +
       			ref:        "refs/tags/v1.2.3",

     

       160
       160
       +
       			expected:   true,

     

       161
       161
       +
       		},

     

       162
       162
       +
       		{

     

       163
       163
       +
       			name:       "tag glob with pattern",

     

       164
       164
       +
       			constraint: Constraint{Tag: []string{"release-*"}},

     

       165
       165
       +
       			ref:        "refs/tags/release-2024",

     

       166
       166
       +
       			expected:   true,

     

       167
       167
       +
       		},

     

       168
       168
       +
       		{

     

       169
       169
       +
       			name:       "tag no match",

     

       170
       170
       +
       			constraint: Constraint{Tag: []string{"v*"}},

     

       171
       171
       +
       			ref:        "refs/tags/release-1.0",

     

       172
       172
       +
       			expected:   false,

     

       173
       173
       +
       		},

     

       174
       174
       +
       		{

     

       175
       175
       +
       			name:       "tag not matched when only branch constraint",

     

       176
       176
       +
       			constraint: Constraint{Branch: []string{"main"}},

     

       177
       177
       +
       			ref:        "refs/tags/v1.0.0",

     

       178
       178
       +
       			expected:   false,

     

       179
       179
       +
       		},

     

       180
       180
       +
       	}

     

       181
       181
       +
       

     

       182
       182
       +
       	for _, tt := range tests {

     

       183
       183
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       184
       184
       +
       			result, _ := tt.constraint.MatchRef(tt.ref)

     

       185
       185
       +
       			assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref)

     

       186
       186
       +
       		})

     

       187
       187
       +
       	}

     

       188
       188
       +
       }

     

       189
       189
       +
       

     

       190
       190
       +
       func TestConstraintMatchRef_Combined(t *testing.T) {

     

       191
       191
       +
       	tests := []struct {

     

       192
       192
       +
       		name       string

     

       193
       193
       +
       		constraint Constraint

     

       194
       194
       +
       		ref        string

     

       195
       195
       +
       		expected   bool

     

       196
       196
       +
       	}{

     

       197
       197
       +
       		{

     

       198
       198
       +
       			name:       "matches branch in combined constraint",

     

       199
       199
       +
       			constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}},

     

       200
       200
       +
       			ref:        "refs/heads/main",

     

       201
       201
       +
       			expected:   true,

     

       202
       202
       +
       		},

     

       203
       203
       +
       		{

     

       204
       204
       +
       			name:       "matches tag in combined constraint",

     

       205
       205
       +
       			constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}},

     

       206
       206
       +
       			ref:        "refs/tags/v1.0.0",

     

       207
       207
       +
       			expected:   true,

     

       208
       208
       +
       		},

     

       209
       209
       +
       		{

     

       210
       210
       +
       			name:       "no match in combined constraint",

     

       211
       211
       +
       			constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}},

     

       212
       212
       +
       			ref:        "refs/heads/develop",

     

       213
       213
       +
       			expected:   false,

     

       214
       214
       +
       		},

     

       215
       215
       +
       		{

     

       216
       216
       +
       			name:       "glob patterns in combined constraint - branch",

     

       217
       217
       +
       			constraint: Constraint{Branch: []string{"release-*"}, Tag: []string{"v*"}},

     

       218
       218
       +
       			ref:        "refs/heads/release-2024",

     

       219
       219
       +
       			expected:   true,

     

       220
       220
       +
       		},

     

       221
       221
       +
       		{

     

       222
       222
       +
       			name:       "glob patterns in combined constraint - tag",

     

       223
       223
       +
       			constraint: Constraint{Branch: []string{"release-*"}, Tag: []string{"v*"}},

     

       224
       224
       +
       			ref:        "refs/tags/v2.0.0",

     

       225
       225
       +
       			expected:   true,

     

       226
       226
       +
       		},

     

       227
       227
       +
       	}

     

       228
       228
       +
       

     

       229
       229
       +
       	for _, tt := range tests {

     

       230
       230
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       231
       231
       +
       			result, _ := tt.constraint.MatchRef(tt.ref)

     

       232
       232
       +
       			assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref)

     

       233
       233
       +
       		})

     

       234
       234
       +
       	}

     

       235
       235
       +
       }

     

       236
       236
       +
       

     

       237
       237
       +
       func TestConstraintMatchBranch_GlobPatterns(t *testing.T) {

     

       238
       238
       +
       	tests := []struct {

     

       239
       239
       +
       		name       string

     

       240
       240
       +
       		constraint Constraint

     

       241
       241
       +
       		branch     string

     

       242
       242
       +
       		expected   bool

     

       243
       243
       +
       	}{

     

       244
       244
       +
       		{

     

       245
       245
       +
       			name:       "exact match",

     

       246
       246
       +
       			constraint: Constraint{Branch: []string{"main"}},

     

       247
       247
       +
       			branch:     "main",

     

       248
       248
       +
       			expected:   true,

     

       249
       249
       +
       		},

     

       250
       250
       +
       		{

     

       251
       251
       +
       			name:       "glob match",

     

       252
       252
       +
       			constraint: Constraint{Branch: []string{"feature-*"}},

     

       253
       253
       +
       			branch:     "feature-123",

     

       254
       254
       +
       			expected:   true,

     

       255
       255
       +
       		},

     

       256
       256
       +
       		{

     

       257
       257
       +
       			name:       "no match",

     

       258
       258
       +
       			constraint: Constraint{Branch: []string{"main"}},

     

       259
       259
       +
       			branch:     "develop",

     

       260
       260
       +
       			expected:   false,

     

       261
       261
       +
       		},

     

       262
       262
       +
       		{

     

       263
       263
       +
       			name:       "multiple patterns with match",

     

       264
       264
       +
       			constraint: Constraint{Branch: []string{"main", "release-*"}},

     

       265
       265
       +
       			branch:     "release-1.0",

     

       266
       266
       +
       			expected:   true,

     

       267
       267
       +
       		},

     

       268
       268
       +
       	}

     

       269
       269
       +
       

     

       270
       270
       +
       	for _, tt := range tests {

     

       271
       271
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       272
       272
       +
       			result, _ := tt.constraint.MatchBranch(tt.branch)

     

       273
       273
       +
       			assert.Equal(t, tt.expected, result, "MatchBranch should return %v for branch %q", tt.expected, tt.branch)

     

       274
       274
       +
       		})

     

       275
       275
       +
       	}

     

       276
       276
       +
       }

     

       277
       277
       +
       

     

       278
       278
       +
       func TestConstraintMatchTag_GlobPatterns(t *testing.T) {

     

       279
       279
       +
       	tests := []struct {

     

       280
       280
       +
       		name       string

     

       281
       281
       +
       		constraint Constraint

     

       282
       282
       +
       		tag        string

     

       283
       283
       +
       		expected   bool

     

       284
       284
       +
       	}{

     

       285
       285
       +
       		{

     

       286
       286
       +
       			name:       "exact match",

     

       287
       287
       +
       			constraint: Constraint{Tag: []string{"v1.0.0"}},

     

       288
       288
       +
       			tag:        "v1.0.0",

     

       289
       289
       +
       			expected:   true,

     

       290
       290
       +
       		},

     

       291
       291
       +
       		{

     

       292
       292
       +
       			name:       "glob match",

     

       293
       293
       +
       			constraint: Constraint{Tag: []string{"v*"}},

     

       294
       294
       +
       			tag:        "v2.3.4",

     

       295
       295
       +
       			expected:   true,

     

       296
       296
       +
       		},

     

       297
       297
       +
       		{

     

       298
       298
       +
       			name:       "no match",

     

       299
       299
       +
       			constraint: Constraint{Tag: []string{"v*"}},

     

       300
       300
       +
       			tag:        "release-1.0",

     

       301
       301
       +
       			expected:   false,

     

       302
       302
       +
       		},

     

       303
       303
       +
       		{

     

       304
       304
       +
       			name:       "multiple patterns with match",

     

       305
       305
       +
       			constraint: Constraint{Tag: []string{"v*", "release-*"}},

     

       306
       306
       +
       			tag:        "release-2024",

     

       307
       307
       +
       			expected:   true,

     

       308
       308
       +
       		},

     

       309
       309
       +
       		{

     

       310
       310
       +
       			name:       "empty tag list matches nothing",

     

       311
       311
       +
       			constraint: Constraint{Tag: []string{}},

     

       312
       312
       +
       			tag:        "v1.0.0",

     

       313
       313
       +
       			expected:   false,

     

       314
       314
       +
       		},

     

       315
       315
       +
       	}

     

       316
       316
       +
       

     

       317
       317
       +
       	for _, tt := range tests {

     

       318
       318
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       319
       319
       +
       			result, _ := tt.constraint.MatchTag(tt.tag)

     

       320
       320
       +
       			assert.Equal(t, tt.expected, result, "MatchTag should return %v for tag %q", tt.expected, tt.tag)

     

       321
       321
       +
       		})

     

       322
       322
       +
       	}

     

       323
       323
       +
       }

Compare changes