+2 -1

appview/db/issues.go

··· 11 11 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 "tangled.org/core/api/tangled" 14 14 + "tangled.org/core/appview/models" 14 15 "tangled.org/core/appview/pagination" 15 16 ) 16 17 ··· 30 31 // optionally, populate this when querying for reverse mappings 31 32 // like comment counts, parent repo etc. 32 33 Comments []IssueComment 33 33 - Labels LabelState 34 34 + Labels models.LabelState 34 35 Repo *Repo 35 36 } 36 37

+33 -496

appview/db/label.go

··· 1 1 package db 2 2 3 3 import ( 4 4 - "crypto/sha1" 5 4 "database/sql" 6 6 - "encoding/hex" 7 7 - "errors" 8 5 "fmt" 9 6 "maps" 10 7 "slices" ··· 12 9 "time" 13 10 14 11 "github.com/bluesky-social/indigo/atproto/syntax" 15 15 - "tangled.sh/tangled.sh/core/api/tangled" 16 16 - "tangled.sh/tangled.sh/core/consts" 17 17 - ) 18 18 - 19 19 - type ConcreteType string 20 20 - 21 21 - const ( 22 22 - ConcreteTypeNull ConcreteType = "null" 23 23 - ConcreteTypeString ConcreteType = "string" 24 24 - ConcreteTypeInt ConcreteType = "integer" 25 25 - ConcreteTypeBool ConcreteType = "boolean" 26 26 - ) 27 27 - 28 28 - type ValueTypeFormat string 29 29 - 30 30 - const ( 31 31 - ValueTypeFormatAny ValueTypeFormat = "any" 32 32 - ValueTypeFormatDid ValueTypeFormat = "did" 12 12 + "tangled.org/core/appview/models" 33 13 ) 34 14 35 35 - // ValueType represents an atproto lexicon type definition with constraints 36 36 - type ValueType struct { 37 37 - Type ConcreteType `json:"type"` 38 38 - Format ValueTypeFormat `json:"format,omitempty"` 39 39 - Enum []string `json:"enum,omitempty"` 40 40 - } 41 41 - 42 42 - func (vt *ValueType) AsRecord() tangled.LabelDefinition_ValueType { 43 43 - return tangled.LabelDefinition_ValueType{ 44 44 - Type: string(vt.Type), 45 45 - Format: string(vt.Format), 46 46 - Enum: vt.Enum, 47 47 - } 48 48 - } 49 49 - 50 50 - func ValueTypeFromRecord(record tangled.LabelDefinition_ValueType) ValueType { 51 51 - return ValueType{ 52 52 - Type: ConcreteType(record.Type), 53 53 - Format: ValueTypeFormat(record.Format), 54 54 - Enum: record.Enum, 55 55 - } 56 56 - } 57 57 - 58 58 - func (vt ValueType) IsConcreteType() bool { 59 59 - return vt.Type == ConcreteTypeNull || 60 60 - vt.Type == ConcreteTypeString || 61 61 - vt.Type == ConcreteTypeInt || 62 62 - vt.Type == ConcreteTypeBool 63 63 - } 64 64 - 65 65 - func (vt ValueType) IsNull() bool { 66 66 - return vt.Type == ConcreteTypeNull 67 67 - } 68 68 - 69 69 - func (vt ValueType) IsString() bool { 70 70 - return vt.Type == ConcreteTypeString 71 71 - } 72 72 - 73 73 - func (vt ValueType) IsInt() bool { 74 74 - return vt.Type == ConcreteTypeInt 75 75 - } 76 76 - 77 77 - func (vt ValueType) IsBool() bool { 78 78 - return vt.Type == ConcreteTypeBool 79 79 - } 80 80 - 81 81 - func (vt ValueType) IsEnum() bool { 82 82 - return len(vt.Enum) > 0 83 83 - } 84 84 - 85 85 - func (vt ValueType) IsDidFormat() bool { 86 86 - return vt.Format == ValueTypeFormatDid 87 87 - } 88 88 - 89 89 - func (vt ValueType) IsAnyFormat() bool { 90 90 - return vt.Format == ValueTypeFormatAny 91 91 - } 92 92 - 93 93 - type LabelDefinition struct { 94 94 - Id int64 95 95 - Did string 96 96 - Rkey string 97 97 - 98 98 - Name string 99 99 - ValueType ValueType 100 100 - Scope []string 101 101 - Color *string 102 102 - Multiple bool 103 103 - Created time.Time 104 104 - } 105 105 - 106 106 - func (l *LabelDefinition) AtUri() syntax.ATURI { 107 107 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", l.Did, tangled.LabelDefinitionNSID, l.Rkey)) 108 108 - } 109 109 - 110 110 - func (l *LabelDefinition) AsRecord() tangled.LabelDefinition { 111 111 - vt := l.ValueType.AsRecord() 112 112 - return tangled.LabelDefinition{ 113 113 - Name: l.Name, 114 114 - Color: l.Color, 115 115 - CreatedAt: l.Created.Format(time.RFC3339), 116 116 - Multiple: &l.Multiple, 117 117 - Scope: l.Scope, 118 118 - ValueType: &vt, 119 119 - } 120 120 - } 121 121 - 122 122 - // random color for a given seed 123 123 - func randomColor(seed string) string { 124 124 - hash := sha1.Sum([]byte(seed)) 125 125 - hexStr := hex.EncodeToString(hash[:]) 126 126 - r := hexStr[0:2] 127 127 - g := hexStr[2:4] 128 128 - b := hexStr[4:6] 129 129 - 130 130 - return fmt.Sprintf("#%s%s%s", r, g, b) 131 131 - } 132 132 - 133 133 - func (ld LabelDefinition) GetColor() string { 134 134 - if ld.Color == nil { 135 135 - seed := fmt.Sprintf("%d:%s:%s", ld.Id, ld.Did, ld.Rkey) 136 136 - color := randomColor(seed) 137 137 - return color 138 138 - } 139 139 - 140 140 - return *ld.Color 141 141 - } 142 142 - 143 143 - func LabelDefinitionFromRecord(did, rkey string, record tangled.LabelDefinition) (*LabelDefinition, error) { 144 144 - created, err := time.Parse(time.RFC3339, record.CreatedAt) 145 145 - if err != nil { 146 146 - created = time.Now() 147 147 - } 148 148 - 149 149 - multiple := false 150 150 - if record.Multiple != nil { 151 151 - multiple = *record.Multiple 152 152 - } 153 153 - 154 154 - var vt ValueType 155 155 - if record.ValueType != nil { 156 156 - vt = ValueTypeFromRecord(*record.ValueType) 157 157 - } 158 158 - 159 159 - return &LabelDefinition{ 160 160 - Did: did, 161 161 - Rkey: rkey, 162 162 - 163 163 - Name: record.Name, 164 164 - ValueType: vt, 165 165 - Scope: record.Scope, 166 166 - Color: record.Color, 167 167 - Multiple: multiple, 168 168 - Created: created, 169 169 - }, nil 170 170 - } 171 171 - 172 172 - func DeleteLabelDefinition(e Execer, filters ...filter) error { 173 173 - var conditions []string 174 174 - var args []any 175 175 - for _, filter := range filters { 176 176 - conditions = append(conditions, filter.Condition()) 177 177 - args = append(args, filter.Arg()...) 178 178 - } 179 179 - whereClause := "" 180 180 - if conditions != nil { 181 181 - whereClause = " where " + strings.Join(conditions, " and ") 182 182 - } 183 183 - query := fmt.Sprintf(`delete from label_definitions %s`, whereClause) 184 184 - _, err := e.Exec(query, args...) 185 185 - return err 186 186 - } 187 187 - 188 15 // no updating type for now 189 189 - func AddLabelDefinition(e Execer, l *LabelDefinition) (int64, error) { 16 16 + func AddLabelDefinition(e Execer, l *models.LabelDefinition) (int64, error) { 190 17 result, err := e.Exec( 191 18 `insert into label_definitions ( 192 19 did, ··· 232 59 return id, nil 233 60 } 234 61 235 235 - func GetLabelDefinitions(e Execer, filters ...filter) ([]LabelDefinition, error) { 236 236 - var labelDefinitions []LabelDefinition 62 62 + func DeleteLabelDefinition(e Execer, filters ...filter) error { 63 63 + var conditions []string 64 64 + var args []any 65 65 + for _, filter := range filters { 66 66 + conditions = append(conditions, filter.Condition()) 67 67 + args = append(args, filter.Arg()...) 68 68 + } 69 69 + whereClause := "" 70 70 + if conditions != nil { 71 71 + whereClause = " where " + strings.Join(conditions, " and ") 72 72 + } 73 73 + query := fmt.Sprintf(`delete from label_definitions %s`, whereClause) 74 74 + _, err := e.Exec(query, args...) 75 75 + return err 76 76 + } 77 77 + 78 78 + func GetLabelDefinitions(e Execer, filters ...filter) ([]models.LabelDefinition, error) { 79 79 + var labelDefinitions []models.LabelDefinition 237 80 var conditions []string 238 81 var args []any 239 82 ··· 275 118 defer rows.Close() 276 119 277 120 for rows.Next() { 278 278 - var labelDefinition LabelDefinition 121 121 + var labelDefinition models.LabelDefinition 279 122 var createdAt, enumVariants, scopes string 280 123 var color sql.Null[string] 281 124 var multiple int ··· 324 167 } 325 168 326 169 // helper to get exactly one label def 327 327 - func GetLabelDefinition(e Execer, filters ...filter) (*LabelDefinition, error) { 170 170 + func GetLabelDefinition(e Execer, filters ...filter) (*models.LabelDefinition, error) { 328 171 labels, err := GetLabelDefinitions(e, filters...) 329 172 if err != nil { 330 173 return nil, err ··· 341 184 return &labels[0], nil 342 185 } 343 186 344 344 - type LabelOp struct { 345 345 - Id int64 346 346 - Did string 347 347 - Rkey string 348 348 - Subject syntax.ATURI 349 349 - Operation LabelOperation 350 350 - OperandKey string 351 351 - OperandValue string 352 352 - PerformedAt time.Time 353 353 - IndexedAt time.Time 354 354 - } 355 355 - 356 356 - func (l LabelOp) SortAt() time.Time { 357 357 - createdAt := l.PerformedAt 358 358 - indexedAt := l.IndexedAt 359 359 - 360 360 - // if we don't have an indexedat, fall back to now 361 361 - if indexedAt.IsZero() { 362 362 - indexedAt = time.Now() 363 363 - } 364 364 - 365 365 - // if createdat is invalid (before epoch), treat as null -> return zero time 366 366 - if createdAt.Before(time.UnixMicro(0)) { 367 367 - return time.Time{} 368 368 - } 369 369 - 370 370 - // if createdat is <= indexedat, use createdat 371 371 - if createdAt.Before(indexedAt) || createdAt.Equal(indexedAt) { 372 372 - return createdAt 373 373 - } 374 374 - 375 375 - // otherwise, createdat is in the future relative to indexedat -> use indexedat 376 376 - return indexedAt 377 377 - } 378 378 - 379 379 - type LabelOperation string 380 380 - 381 381 - const ( 382 382 - LabelOperationAdd LabelOperation = "add" 383 383 - LabelOperationDel LabelOperation = "del" 384 384 - ) 385 385 - 386 386 - // a record can create multiple label ops 387 387 - func LabelOpsFromRecord(did, rkey string, record tangled.LabelOp) []LabelOp { 388 388 - performed, err := time.Parse(time.RFC3339, record.PerformedAt) 389 389 - if err != nil { 390 390 - performed = time.Now() 391 391 - } 392 392 - 393 393 - mkOp := func(operand *tangled.LabelOp_Operand) LabelOp { 394 394 - return LabelOp{ 395 395 - Did: did, 396 396 - Rkey: rkey, 397 397 - Subject: syntax.ATURI(record.Subject), 398 398 - OperandKey: operand.Key, 399 399 - OperandValue: operand.Value, 400 400 - PerformedAt: performed, 401 401 - } 402 402 - } 403 403 - 404 404 - var ops []LabelOp 405 405 - for _, o := range record.Add { 406 406 - if o != nil { 407 407 - op := mkOp(o) 408 408 - op.Operation = LabelOperationAdd 409 409 - ops = append(ops, op) 410 410 - } 411 411 - } 412 412 - for _, o := range record.Delete { 413 413 - if o != nil { 414 414 - op := mkOp(o) 415 415 - op.Operation = LabelOperationDel 416 416 - ops = append(ops, op) 417 417 - } 418 418 - } 419 419 - 420 420 - return ops 421 421 - } 422 422 - 423 423 - func LabelOpsAsRecord(ops []LabelOp) tangled.LabelOp { 424 424 - if len(ops) == 0 { 425 425 - return tangled.LabelOp{} 426 426 - } 427 427 - 428 428 - // use the first operation to establish common fields 429 429 - first := ops[0] 430 430 - record := tangled.LabelOp{ 431 431 - Subject: string(first.Subject), 432 432 - PerformedAt: first.PerformedAt.Format(time.RFC3339), 433 433 - } 434 434 - 435 435 - var addOperands []*tangled.LabelOp_Operand 436 436 - var deleteOperands []*tangled.LabelOp_Operand 437 437 - 438 438 - for _, op := range ops { 439 439 - operand := &tangled.LabelOp_Operand{ 440 440 - Key: op.OperandKey, 441 441 - Value: op.OperandValue, 442 442 - } 443 443 - 444 444 - switch op.Operation { 445 445 - case LabelOperationAdd: 446 446 - addOperands = append(addOperands, operand) 447 447 - case LabelOperationDel: 448 448 - deleteOperands = append(deleteOperands, operand) 449 449 - default: 450 450 - return tangled.LabelOp{} 451 451 - } 452 452 - } 453 453 - 454 454 - record.Add = addOperands 455 455 - record.Delete = deleteOperands 456 456 - 457 457 - return record 458 458 - } 459 459 - 460 460 - func AddLabelOp(e Execer, l *LabelOp) (int64, error) { 187 187 + func AddLabelOp(e Execer, l *models.LabelOp) (int64, error) { 461 188 now := time.Now() 462 189 result, err := e.Exec( 463 190 `insert into label_ops ( ··· 500 227 return id, nil 501 228 } 502 229 503 503 - func GetLabelOps(e Execer, filters ...filter) ([]LabelOp, error) { 504 504 - var labelOps []LabelOp 230 230 + func GetLabelOps(e Execer, filters ...filter) ([]models.LabelOp, error) { 231 231 + var labelOps []models.LabelOp 505 232 var conditions []string 506 233 var args []any 507 234 ··· 541 268 defer rows.Close() 542 269 543 270 for rows.Next() { 544 544 - var labelOp LabelOp 271 271 + var labelOp models.LabelOp 545 272 var performedAt, indexedAt string 546 273 547 274 if err := rows.Scan( ··· 575 302 } 576 303 577 304 // get labels for a given list of subject URIs 578 578 - func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]LabelState, error) { 305 305 + func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]models.LabelState, error) { 579 306 ops, err := GetLabelOps(e, filters...) 580 307 if err != nil { 581 308 return nil, err 582 309 } 583 310 584 311 // group ops by subject 585 585 - opsBySubject := make(map[syntax.ATURI][]LabelOp) 312 312 + opsBySubject := make(map[syntax.ATURI][]models.LabelOp) 586 313 for _, op := range ops { 587 314 subject := syntax.ATURI(op.Subject) 588 315 opsBySubject[subject] = append(opsBySubject[subject], op) ··· 601 328 } 602 329 603 330 // apply label ops for each subject and collect results 604 604 - results := make(map[syntax.ATURI]LabelState) 331 331 + results := make(map[syntax.ATURI]models.LabelState) 605 332 for subject, subjectOps := range opsBySubject { 606 606 - state := NewLabelState() 333 333 + state := models.NewLabelState() 607 334 actx.ApplyLabelOps(state, subjectOps) 608 335 results[subject] = state 609 336 } ··· 611 338 return results, nil 612 339 } 613 340 614 614 - type set = map[string]struct{} 615 615 - 616 616 - type LabelState struct { 617 617 - inner map[string]set 618 618 - } 619 619 - 620 620 - func NewLabelState() LabelState { 621 621 - return LabelState{ 622 622 - inner: make(map[string]set), 623 623 - } 624 624 - } 625 625 - 626 626 - func (s LabelState) Inner() map[string]set { 627 627 - return s.inner 628 628 - } 629 629 - 630 630 - func (s LabelState) ContainsLabel(l string) bool { 631 631 - if valset, exists := s.inner[l]; exists { 632 632 - if valset != nil { 633 633 - return true 634 634 - } 635 635 - } 636 636 - 637 637 - return false 638 638 - } 639 639 - 640 640 - // go maps behavior in templates make this necessary, 641 641 - // indexing a map and getting `set` in return is apparently truthy 642 642 - func (s LabelState) ContainsLabelAndVal(l, v string) bool { 643 643 - if valset, exists := s.inner[l]; exists { 644 644 - if _, exists := valset[v]; exists { 645 645 - return true 646 646 - } 647 647 - } 648 648 - 649 649 - return false 650 650 - } 651 651 - 652 652 - func (s LabelState) GetValSet(l string) set { 653 653 - if valset, exists := s.inner[l]; exists { 654 654 - return valset 655 655 - } else { 656 656 - return make(set) 657 657 - } 658 658 - } 659 659 - 660 660 - type LabelApplicationCtx struct { 661 661 - Defs map[string]*LabelDefinition // labelAt -> labelDef 662 662 - } 663 663 - 664 664 - var ( 665 665 - LabelNoOpError = errors.New("no-op") 666 666 - ) 667 667 - 668 668 - func NewLabelApplicationCtx(e Execer, filters ...filter) (*LabelApplicationCtx, error) { 341 341 + func NewLabelApplicationCtx(e Execer, filters ...filter) (*models.LabelApplicationCtx, error) { 669 342 labels, err := GetLabelDefinitions(e, filters...) 670 343 if err != nil { 671 344 return nil, err 672 345 } 673 346 674 674 - defs := make(map[string]*LabelDefinition) 347 347 + defs := make(map[string]*models.LabelDefinition) 675 348 for _, l := range labels { 676 349 defs[l.AtUri().String()] = &l 677 350 } 678 351 679 679 - return &LabelApplicationCtx{defs}, nil 680 680 - } 681 681 - 682 682 - func (c *LabelApplicationCtx) ApplyLabelOp(state LabelState, op LabelOp) error { 683 683 - def, ok := c.Defs[op.OperandKey] 684 684 - if !ok { 685 685 - // this def was deleted, but an op exists, so we just skip over the op 686 686 - return nil 687 687 - } 688 688 - 689 689 - switch op.Operation { 690 690 - case LabelOperationAdd: 691 691 - // if valueset is empty, init it 692 692 - if state.inner[op.OperandKey] == nil { 693 693 - state.inner[op.OperandKey] = make(set) 694 694 - } 695 695 - 696 696 - // if valueset is populated & this val alr exists, this labelop is a noop 697 697 - if valueSet, exists := state.inner[op.OperandKey]; exists { 698 698 - if _, exists = valueSet[op.OperandValue]; exists { 699 699 - return LabelNoOpError 700 700 - } 701 701 - } 702 702 - 703 703 - if def.Multiple { 704 704 - // append to set 705 705 - state.inner[op.OperandKey][op.OperandValue] = struct{}{} 706 706 - } else { 707 707 - // reset to just this value 708 708 - state.inner[op.OperandKey] = set{op.OperandValue: struct{}{}} 709 709 - } 710 710 - 711 711 - case LabelOperationDel: 712 712 - // if label DNE, then deletion is a no-op 713 713 - if valueSet, exists := state.inner[op.OperandKey]; !exists { 714 714 - return LabelNoOpError 715 715 - } else if _, exists = valueSet[op.OperandValue]; !exists { // if value DNE, then deletion is no-op 716 716 - return LabelNoOpError 717 717 - } 718 718 - 719 719 - if def.Multiple { 720 720 - // remove from set 721 721 - delete(state.inner[op.OperandKey], op.OperandValue) 722 722 - } else { 723 723 - // reset the entire label 724 724 - delete(state.inner, op.OperandKey) 725 725 - } 726 726 - 727 727 - // if the map becomes empty, then set it to nil, this is just the inverse of add 728 728 - if len(state.inner[op.OperandKey]) == 0 { 729 729 - state.inner[op.OperandKey] = nil 730 730 - } 731 731 - 732 732 - } 733 733 - 734 734 - return nil 735 735 - } 736 736 - 737 737 - func (c *LabelApplicationCtx) ApplyLabelOps(state LabelState, ops []LabelOp) { 738 738 - // sort label ops in sort order first 739 739 - slices.SortFunc(ops, func(a, b LabelOp) int { 740 740 - return a.SortAt().Compare(b.SortAt()) 741 741 - }) 742 742 - 743 743 - // apply ops in sequence 744 744 - for _, o := range ops { 745 745 - _ = c.ApplyLabelOp(state, o) 746 746 - } 747 747 - } 748 748 - 749 749 - // IsInverse checks if one label operation is the inverse of another 750 750 - // returns true if one is an add and the other is a delete with the same key and value 751 751 - func (op1 LabelOp) IsInverse(op2 LabelOp) bool { 752 752 - if op1.OperandKey != op2.OperandKey || op1.OperandValue != op2.OperandValue { 753 753 - return false 754 754 - } 755 755 - 756 756 - return (op1.Operation == LabelOperationAdd && op2.Operation == LabelOperationDel) || 757 757 - (op1.Operation == LabelOperationDel && op2.Operation == LabelOperationAdd) 758 758 - } 759 759 - 760 760 - // removes pairs of label operations that are inverses of each other 761 761 - // from the given slice. the function preserves the order of remaining operations. 762 762 - func ReduceLabelOps(ops []LabelOp) []LabelOp { 763 763 - if len(ops) <= 1 { 764 764 - return ops 765 765 - } 766 766 - 767 767 - keep := make([]bool, len(ops)) 768 768 - for i := range keep { 769 769 - keep[i] = true 770 770 - } 771 771 - 772 772 - for i := range ops { 773 773 - if !keep[i] { 774 774 - continue 775 775 - } 776 776 - 777 777 - for j := i + 1; j < len(ops); j++ { 778 778 - if !keep[j] { 779 779 - continue 780 780 - } 781 781 - 782 782 - if ops[i].IsInverse(ops[j]) { 783 783 - keep[i] = false 784 784 - keep[j] = false 785 785 - break // move to next i since this one is now eliminated 786 786 - } 787 787 - } 788 788 - } 789 789 - 790 790 - // build result slice with only kept operations 791 791 - var result []LabelOp 792 792 - for i, op := range ops { 793 793 - if keep[i] { 794 794 - result = append(result, op) 795 795 - } 796 796 - } 797 797 - 798 798 - return result 799 799 - } 800 800 - 801 801 - func DefaultLabelDefs() []string { 802 802 - rkeys := []string{ 803 803 - "wontfix", 804 804 - "duplicate", 805 805 - "assignee", 806 806 - "good-first-issue", 807 807 - "documentation", 808 808 - } 809 809 - 810 810 - defs := make([]string, len(rkeys)) 811 811 - for i, r := range rkeys { 812 812 - defs[i] = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, r) 813 813 - } 814 814 - 815 815 - return defs 352 352 + return &models.LabelApplicationCtx{defs}, nil 816 353 }

+1 -1

appview/ingester.go

··· 923 923 return fmt.Errorf("invalid record: %w", err) 924 924 } 925 925 926 926 - def, err := db.LabelDefinitionFromRecord(did, rkey, record) 926 926 + def, err := models.LabelDefinitionFromRecord(did, rkey, record) 927 927 if err != nil { 928 928 return fmt.Errorf("failed to parse labeldef from record: %w", err) 929 929 }

+3 -2

appview/issues/issues.go

··· 19 19 "tangled.org/core/api/tangled" 20 20 "tangled.org/core/appview/config" 21 21 "tangled.org/core/appview/db" 22 22 + "tangled.org/core/appview/models" 22 23 "tangled.org/core/appview/notify" 23 24 "tangled.org/core/appview/oauth" 24 25 "tangled.org/core/appview/pages" ··· 103 104 return 104 105 } 105 106 106 106 - defs := make(map[string]*db.LabelDefinition) 107 107 + defs := make(map[string]*models.LabelDefinition) 107 108 for _, l := range labelDefs { 108 109 defs[l.AtUri().String()] = &l 109 110 } ··· 796 797 return 797 798 } 798 799 799 799 - defs := make(map[string]*db.LabelDefinition) 800 800 + defs := make(map[string]*models.LabelDefinition) 800 801 for _, l := range labelDefs { 801 802 defs[l.AtUri().String()] = &l 802 803 }

+10 -9

appview/labels/labels.go

··· 17 17 "tangled.sh/tangled.sh/core/api/tangled" 18 18 "tangled.sh/tangled.sh/core/appview/db" 19 19 "tangled.sh/tangled.sh/core/appview/middleware" 20 20 + "tangled.sh/tangled.sh/core/appview/models" 20 21 "tangled.sh/tangled.sh/core/appview/oauth" 21 22 "tangled.sh/tangled.sh/core/appview/pages" 22 23 "tangled.sh/tangled.sh/core/appview/validator" ··· 113 114 return 114 115 } 115 116 116 116 - labelState := db.NewLabelState() 117 117 + labelState := models.NewLabelState() 117 118 actx.ApplyLabelOps(labelState, existingOps) 118 119 119 119 - var labelOps []db.LabelOp 120 120 + var labelOps []models.LabelOp 120 121 121 122 // first delete all existing state 122 123 for key, vals := range labelState.Inner() { 123 124 for val := range vals { 124 124 - labelOps = append(labelOps, db.LabelOp{ 125 125 + labelOps = append(labelOps, models.LabelOp{ 125 126 Did: did, 126 127 Rkey: rkey, 127 128 Subject: syntax.ATURI(subjectUri), 128 128 - Operation: db.LabelOperationDel, 129 129 + Operation: models.LabelOperationDel, 129 130 OperandKey: key, 130 131 OperandValue: val, 131 132 PerformedAt: performedAt, ··· 141 142 } 142 143 143 144 for _, val := range vals { 144 144 - labelOps = append(labelOps, db.LabelOp{ 145 145 + labelOps = append(labelOps, models.LabelOp{ 145 146 Did: did, 146 147 Rkey: rkey, 147 148 Subject: syntax.ATURI(subjectUri), 148 148 - Operation: db.LabelOperationAdd, 149 149 + Operation: models.LabelOperationAdd, 149 150 OperandKey: key, 150 151 OperandValue: val, 151 152 PerformedAt: performedAt, ··· 155 156 } 156 157 157 158 // reduce the opset 158 158 - labelOps = db.ReduceLabelOps(labelOps) 159 159 + labelOps = models.ReduceLabelOps(labelOps) 159 160 160 161 for i := range labelOps { 161 162 def := actx.Defs[labelOps[i].OperandKey] ··· 168 169 // next, apply all ops introduced in this request and filter out ones that are no-ops 169 170 validLabelOps := labelOps[:0] 170 171 for _, op := range labelOps { 171 171 - if err = actx.ApplyLabelOp(labelState, op); err != db.LabelNoOpError { 172 172 + if err = actx.ApplyLabelOp(labelState, op); err != models.LabelNoOpError { 172 173 validLabelOps = append(validLabelOps, op) 173 174 } 174 175 } ··· 180 181 } 181 182 182 183 // create an atproto record of valid ops 183 183 - record := db.LabelOpsAsRecord(validLabelOps) 184 184 + record := models.LabelOpsAsRecord(validLabelOps) 184 185 185 186 client, err := l.oauth.AuthorizedClient(r) 186 187 if err != nil {

+473

appview/models/label.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "crypto/sha1" 5 5 + "encoding/hex" 6 6 + "errors" 7 7 + "fmt" 8 8 + "slices" 9 9 + "time" 10 10 + 11 11 + "github.com/bluesky-social/indigo/atproto/syntax" 12 12 + "tangled.org/core/api/tangled" 13 13 + "tangled.org/core/consts" 14 14 + ) 15 15 + 16 16 + type ConcreteType string 17 17 + 18 18 + const ( 19 19 + ConcreteTypeNull ConcreteType = "null" 20 20 + ConcreteTypeString ConcreteType = "string" 21 21 + ConcreteTypeInt ConcreteType = "integer" 22 22 + ConcreteTypeBool ConcreteType = "boolean" 23 23 + ) 24 24 + 25 25 + type ValueTypeFormat string 26 26 + 27 27 + const ( 28 28 + ValueTypeFormatAny ValueTypeFormat = "any" 29 29 + ValueTypeFormatDid ValueTypeFormat = "did" 30 30 + ) 31 31 + 32 32 + // ValueType represents an atproto lexicon type definition with constraints 33 33 + type ValueType struct { 34 34 + Type ConcreteType `json:"type"` 35 35 + Format ValueTypeFormat `json:"format,omitempty"` 36 36 + Enum []string `json:"enum,omitempty"` 37 37 + } 38 38 + 39 39 + func (vt *ValueType) AsRecord() tangled.LabelDefinition_ValueType { 40 40 + return tangled.LabelDefinition_ValueType{ 41 41 + Type: string(vt.Type), 42 42 + Format: string(vt.Format), 43 43 + Enum: vt.Enum, 44 44 + } 45 45 + } 46 46 + 47 47 + func ValueTypeFromRecord(record tangled.LabelDefinition_ValueType) ValueType { 48 48 + return ValueType{ 49 49 + Type: ConcreteType(record.Type), 50 50 + Format: ValueTypeFormat(record.Format), 51 51 + Enum: record.Enum, 52 52 + } 53 53 + } 54 54 + 55 55 + func (vt ValueType) IsConcreteType() bool { 56 56 + return vt.Type == ConcreteTypeNull || 57 57 + vt.Type == ConcreteTypeString || 58 58 + vt.Type == ConcreteTypeInt || 59 59 + vt.Type == ConcreteTypeBool 60 60 + } 61 61 + 62 62 + func (vt ValueType) IsNull() bool { 63 63 + return vt.Type == ConcreteTypeNull 64 64 + } 65 65 + 66 66 + func (vt ValueType) IsString() bool { 67 67 + return vt.Type == ConcreteTypeString 68 68 + } 69 69 + 70 70 + func (vt ValueType) IsInt() bool { 71 71 + return vt.Type == ConcreteTypeInt 72 72 + } 73 73 + 74 74 + func (vt ValueType) IsBool() bool { 75 75 + return vt.Type == ConcreteTypeBool 76 76 + } 77 77 + 78 78 + func (vt ValueType) IsEnum() bool { 79 79 + return len(vt.Enum) > 0 80 80 + } 81 81 + 82 82 + func (vt ValueType) IsDidFormat() bool { 83 83 + return vt.Format == ValueTypeFormatDid 84 84 + } 85 85 + 86 86 + func (vt ValueType) IsAnyFormat() bool { 87 87 + return vt.Format == ValueTypeFormatAny 88 88 + } 89 89 + 90 90 + type LabelDefinition struct { 91 91 + Id int64 92 92 + Did string 93 93 + Rkey string 94 94 + 95 95 + Name string 96 96 + ValueType ValueType 97 97 + Scope []string 98 98 + Color *string 99 99 + Multiple bool 100 100 + Created time.Time 101 101 + } 102 102 + 103 103 + func (l *LabelDefinition) AtUri() syntax.ATURI { 104 104 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", l.Did, tangled.LabelDefinitionNSID, l.Rkey)) 105 105 + } 106 106 + 107 107 + func (l *LabelDefinition) AsRecord() tangled.LabelDefinition { 108 108 + vt := l.ValueType.AsRecord() 109 109 + return tangled.LabelDefinition{ 110 110 + Name: l.Name, 111 111 + Color: l.Color, 112 112 + CreatedAt: l.Created.Format(time.RFC3339), 113 113 + Multiple: &l.Multiple, 114 114 + Scope: l.Scope, 115 115 + ValueType: &vt, 116 116 + } 117 117 + } 118 118 + 119 119 + // random color for a given seed 120 120 + func randomColor(seed string) string { 121 121 + hash := sha1.Sum([]byte(seed)) 122 122 + hexStr := hex.EncodeToString(hash[:]) 123 123 + r := hexStr[0:2] 124 124 + g := hexStr[2:4] 125 125 + b := hexStr[4:6] 126 126 + 127 127 + return fmt.Sprintf("#%s%s%s", r, g, b) 128 128 + } 129 129 + 130 130 + func (ld LabelDefinition) GetColor() string { 131 131 + if ld.Color == nil { 132 132 + seed := fmt.Sprintf("%d:%s:%s", ld.Id, ld.Did, ld.Rkey) 133 133 + color := randomColor(seed) 134 134 + return color 135 135 + } 136 136 + 137 137 + return *ld.Color 138 138 + } 139 139 + 140 140 + func LabelDefinitionFromRecord(did, rkey string, record tangled.LabelDefinition) (*LabelDefinition, error) { 141 141 + created, err := time.Parse(time.RFC3339, record.CreatedAt) 142 142 + if err != nil { 143 143 + created = time.Now() 144 144 + } 145 145 + 146 146 + multiple := false 147 147 + if record.Multiple != nil { 148 148 + multiple = *record.Multiple 149 149 + } 150 150 + 151 151 + var vt ValueType 152 152 + if record.ValueType != nil { 153 153 + vt = ValueTypeFromRecord(*record.ValueType) 154 154 + } 155 155 + 156 156 + return &LabelDefinition{ 157 157 + Did: did, 158 158 + Rkey: rkey, 159 159 + 160 160 + Name: record.Name, 161 161 + ValueType: vt, 162 162 + Scope: record.Scope, 163 163 + Color: record.Color, 164 164 + Multiple: multiple, 165 165 + Created: created, 166 166 + }, nil 167 167 + } 168 168 + 169 169 + type LabelOp struct { 170 170 + Id int64 171 171 + Did string 172 172 + Rkey string 173 173 + Subject syntax.ATURI 174 174 + Operation LabelOperation 175 175 + OperandKey string 176 176 + OperandValue string 177 177 + PerformedAt time.Time 178 178 + IndexedAt time.Time 179 179 + } 180 180 + 181 181 + func (l LabelOp) SortAt() time.Time { 182 182 + createdAt := l.PerformedAt 183 183 + indexedAt := l.IndexedAt 184 184 + 185 185 + // if we don't have an indexedat, fall back to now 186 186 + if indexedAt.IsZero() { 187 187 + indexedAt = time.Now() 188 188 + } 189 189 + 190 190 + // if createdat is invalid (before epoch), treat as null -> return zero time 191 191 + if createdAt.Before(time.UnixMicro(0)) { 192 192 + return time.Time{} 193 193 + } 194 194 + 195 195 + // if createdat is <= indexedat, use createdat 196 196 + if createdAt.Before(indexedAt) || createdAt.Equal(indexedAt) { 197 197 + return createdAt 198 198 + } 199 199 + 200 200 + // otherwise, createdat is in the future relative to indexedat -> use indexedat 201 201 + return indexedAt 202 202 + } 203 203 + 204 204 + type LabelOperation string 205 205 + 206 206 + const ( 207 207 + LabelOperationAdd LabelOperation = "add" 208 208 + LabelOperationDel LabelOperation = "del" 209 209 + ) 210 210 + 211 211 + // a record can create multiple label ops 212 212 + func LabelOpsFromRecord(did, rkey string, record tangled.LabelOp) []LabelOp { 213 213 + performed, err := time.Parse(time.RFC3339, record.PerformedAt) 214 214 + if err != nil { 215 215 + performed = time.Now() 216 216 + } 217 217 + 218 218 + mkOp := func(operand *tangled.LabelOp_Operand) LabelOp { 219 219 + return LabelOp{ 220 220 + Did: did, 221 221 + Rkey: rkey, 222 222 + Subject: syntax.ATURI(record.Subject), 223 223 + OperandKey: operand.Key, 224 224 + OperandValue: operand.Value, 225 225 + PerformedAt: performed, 226 226 + } 227 227 + } 228 228 + 229 229 + var ops []LabelOp 230 230 + for _, o := range record.Add { 231 231 + if o != nil { 232 232 + op := mkOp(o) 233 233 + op.Operation = LabelOperationAdd 234 234 + ops = append(ops, op) 235 235 + } 236 236 + } 237 237 + for _, o := range record.Delete { 238 238 + if o != nil { 239 239 + op := mkOp(o) 240 240 + op.Operation = LabelOperationDel 241 241 + ops = append(ops, op) 242 242 + } 243 243 + } 244 244 + 245 245 + return ops 246 246 + } 247 247 + 248 248 + func LabelOpsAsRecord(ops []LabelOp) tangled.LabelOp { 249 249 + if len(ops) == 0 { 250 250 + return tangled.LabelOp{} 251 251 + } 252 252 + 253 253 + // use the first operation to establish common fields 254 254 + first := ops[0] 255 255 + record := tangled.LabelOp{ 256 256 + Subject: string(first.Subject), 257 257 + PerformedAt: first.PerformedAt.Format(time.RFC3339), 258 258 + } 259 259 + 260 260 + var addOperands []*tangled.LabelOp_Operand 261 261 + var deleteOperands []*tangled.LabelOp_Operand 262 262 + 263 263 + for _, op := range ops { 264 264 + operand := &tangled.LabelOp_Operand{ 265 265 + Key: op.OperandKey, 266 266 + Value: op.OperandValue, 267 267 + } 268 268 + 269 269 + switch op.Operation { 270 270 + case LabelOperationAdd: 271 271 + addOperands = append(addOperands, operand) 272 272 + case LabelOperationDel: 273 273 + deleteOperands = append(deleteOperands, operand) 274 274 + default: 275 275 + return tangled.LabelOp{} 276 276 + } 277 277 + } 278 278 + 279 279 + record.Add = addOperands 280 280 + record.Delete = deleteOperands 281 281 + 282 282 + return record 283 283 + } 284 284 + 285 285 + type set = map[string]struct{} 286 286 + 287 287 + type LabelState struct { 288 288 + inner map[string]set 289 289 + } 290 290 + 291 291 + func NewLabelState() LabelState { 292 292 + return LabelState{ 293 293 + inner: make(map[string]set), 294 294 + } 295 295 + } 296 296 + 297 297 + func (s LabelState) Inner() map[string]set { 298 298 + return s.inner 299 299 + } 300 300 + 301 301 + func (s LabelState) ContainsLabel(l string) bool { 302 302 + if valset, exists := s.inner[l]; exists { 303 303 + if valset != nil { 304 304 + return true 305 305 + } 306 306 + } 307 307 + 308 308 + return false 309 309 + } 310 310 + 311 311 + // go maps behavior in templates make this necessary, 312 312 + // indexing a map and getting `set` in return is apparently truthy 313 313 + func (s LabelState) ContainsLabelAndVal(l, v string) bool { 314 314 + if valset, exists := s.inner[l]; exists { 315 315 + if _, exists := valset[v]; exists { 316 316 + return true 317 317 + } 318 318 + } 319 319 + 320 320 + return false 321 321 + } 322 322 + 323 323 + func (s LabelState) GetValSet(l string) set { 324 324 + if valset, exists := s.inner[l]; exists { 325 325 + return valset 326 326 + } else { 327 327 + return make(set) 328 328 + } 329 329 + } 330 330 + 331 331 + type LabelApplicationCtx struct { 332 332 + Defs map[string]*LabelDefinition // labelAt -> labelDef 333 333 + } 334 334 + 335 335 + var ( 336 336 + LabelNoOpError = errors.New("no-op") 337 337 + ) 338 338 + 339 339 + func (c *LabelApplicationCtx) ApplyLabelOp(state LabelState, op LabelOp) error { 340 340 + def, ok := c.Defs[op.OperandKey] 341 341 + if !ok { 342 342 + // this def was deleted, but an op exists, so we just skip over the op 343 343 + return nil 344 344 + } 345 345 + 346 346 + switch op.Operation { 347 347 + case LabelOperationAdd: 348 348 + // if valueset is empty, init it 349 349 + if state.inner[op.OperandKey] == nil { 350 350 + state.inner[op.OperandKey] = make(set) 351 351 + } 352 352 + 353 353 + // if valueset is populated & this val alr exists, this labelop is a noop 354 354 + if valueSet, exists := state.inner[op.OperandKey]; exists { 355 355 + if _, exists = valueSet[op.OperandValue]; exists { 356 356 + return LabelNoOpError 357 357 + } 358 358 + } 359 359 + 360 360 + if def.Multiple { 361 361 + // append to set 362 362 + state.inner[op.OperandKey][op.OperandValue] = struct{}{} 363 363 + } else { 364 364 + // reset to just this value 365 365 + state.inner[op.OperandKey] = set{op.OperandValue: struct{}{}} 366 366 + } 367 367 + 368 368 + case LabelOperationDel: 369 369 + // if label DNE, then deletion is a no-op 370 370 + if valueSet, exists := state.inner[op.OperandKey]; !exists { 371 371 + return LabelNoOpError 372 372 + } else if _, exists = valueSet[op.OperandValue]; !exists { // if value DNE, then deletion is no-op 373 373 + return LabelNoOpError 374 374 + } 375 375 + 376 376 + if def.Multiple { 377 377 + // remove from set 378 378 + delete(state.inner[op.OperandKey], op.OperandValue) 379 379 + } else { 380 380 + // reset the entire label 381 381 + delete(state.inner, op.OperandKey) 382 382 + } 383 383 + 384 384 + // if the map becomes empty, then set it to nil, this is just the inverse of add 385 385 + if len(state.inner[op.OperandKey]) == 0 { 386 386 + state.inner[op.OperandKey] = nil 387 387 + } 388 388 + 389 389 + } 390 390 + 391 391 + return nil 392 392 + } 393 393 + 394 394 + func (c *LabelApplicationCtx) ApplyLabelOps(state LabelState, ops []LabelOp) { 395 395 + // sort label ops in sort order first 396 396 + slices.SortFunc(ops, func(a, b LabelOp) int { 397 397 + return a.SortAt().Compare(b.SortAt()) 398 398 + }) 399 399 + 400 400 + // apply ops in sequence 401 401 + for _, o := range ops { 402 402 + _ = c.ApplyLabelOp(state, o) 403 403 + } 404 404 + } 405 405 + 406 406 + // IsInverse checks if one label operation is the inverse of another 407 407 + // returns true if one is an add and the other is a delete with the same key and value 408 408 + func (op1 LabelOp) IsInverse(op2 LabelOp) bool { 409 409 + if op1.OperandKey != op2.OperandKey || op1.OperandValue != op2.OperandValue { 410 410 + return false 411 411 + } 412 412 + 413 413 + return (op1.Operation == LabelOperationAdd && op2.Operation == LabelOperationDel) || 414 414 + (op1.Operation == LabelOperationDel && op2.Operation == LabelOperationAdd) 415 415 + } 416 416 + 417 417 + // removes pairs of label operations that are inverses of each other 418 418 + // from the given slice. the function preserves the order of remaining operations. 419 419 + func ReduceLabelOps(ops []LabelOp) []LabelOp { 420 420 + if len(ops) <= 1 { 421 421 + return ops 422 422 + } 423 423 + 424 424 + keep := make([]bool, len(ops)) 425 425 + for i := range keep { 426 426 + keep[i] = true 427 427 + } 428 428 + 429 429 + for i := range ops { 430 430 + if !keep[i] { 431 431 + continue 432 432 + } 433 433 + 434 434 + for j := i + 1; j < len(ops); j++ { 435 435 + if !keep[j] { 436 436 + continue 437 437 + } 438 438 + 439 439 + if ops[i].IsInverse(ops[j]) { 440 440 + keep[i] = false 441 441 + keep[j] = false 442 442 + break // move to next i since this one is now eliminated 443 443 + } 444 444 + } 445 445 + } 446 446 + 447 447 + // build result slice with only kept operations 448 448 + var result []LabelOp 449 449 + for i, op := range ops { 450 450 + if keep[i] { 451 451 + result = append(result, op) 452 452 + } 453 453 + } 454 454 + 455 455 + return result 456 456 + } 457 457 + 458 458 + func DefaultLabelDefs() []string { 459 459 + rkeys := []string{ 460 460 + "wontfix", 461 461 + "duplicate", 462 462 + "assignee", 463 463 + "good-first-issue", 464 464 + "documentation", 465 465 + } 466 466 + 467 467 + defs := make([]string, len(rkeys)) 468 468 + for i, r := range rkeys { 469 469 + defs[i] = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, r) 470 470 + } 471 471 + 472 472 + return defs 473 473 + }

+8 -8

appview/pages/pages.go

··· 841 841 type RepoGeneralSettingsParams struct { 842 842 LoggedInUser *oauth.User 843 843 RepoInfo repoinfo.RepoInfo 844 844 - Labels []db.LabelDefinition 845 845 - DefaultLabels []db.LabelDefinition 844 844 + Labels []models.LabelDefinition 845 845 + DefaultLabels []models.LabelDefinition 846 846 SubscribedLabels map[string]struct{} 847 847 Active string 848 848 Tabs []map[string]any ··· 890 890 RepoInfo repoinfo.RepoInfo 891 891 Active string 892 892 Issues []db.Issue 893 893 - LabelDefs map[string]*db.LabelDefinition 893 893 + LabelDefs map[string]*models.LabelDefinition 894 894 Page pagination.Page 895 895 FilteringByOpen bool 896 896 } ··· 906 906 Active string 907 907 Issue *db.Issue 908 908 CommentList []db.CommentListItem 909 909 - LabelDefs map[string]*db.LabelDefinition 909 909 + LabelDefs map[string]*models.LabelDefinition 910 910 911 911 OrderedReactionKinds []db.ReactionKind 912 912 Reactions map[db.ReactionKind]int ··· 1236 1236 type LabelPanelParams struct { 1237 1237 LoggedInUser *oauth.User 1238 1238 RepoInfo repoinfo.RepoInfo 1239 1239 - Defs map[string]*db.LabelDefinition 1239 1239 + Defs map[string]*models.LabelDefinition 1240 1240 Subject string 1241 1241 - State db.LabelState 1241 1241 + State models.LabelState 1242 1242 } 1243 1243 1244 1244 func (p *Pages) LabelPanel(w io.Writer, params LabelPanelParams) error { ··· 1248 1248 type EditLabelPanelParams struct { 1249 1249 LoggedInUser *oauth.User 1250 1250 RepoInfo repoinfo.RepoInfo 1251 1251 - Defs map[string]*db.LabelDefinition 1251 1251 + Defs map[string]*models.LabelDefinition 1252 1252 Subject string 1253 1253 - State db.LabelState 1253 1253 + State models.LabelState 1254 1254 } 1255 1255 1256 1256 func (p *Pages) EditLabelPanel(w io.Writer, params EditLabelPanelParams) error {

+8 -8

appview/repo/repo.go

··· 1005 1005 concreteType = "null" 1006 1006 } 1007 1007 1008 1008 - format := db.ValueTypeFormatAny 1008 1008 + format := models.ValueTypeFormatAny 1009 1009 if valueFormat == "did" { 1010 1010 - format = db.ValueTypeFormatDid 1010 1010 + format = models.ValueTypeFormatDid 1011 1011 } 1012 1012 1013 1013 - valueType := db.ValueType{ 1014 1014 - Type: db.ConcreteType(concreteType), 1013 1013 + valueType := models.ValueType{ 1014 1014 + Type: models.ConcreteType(concreteType), 1015 1015 Format: format, 1016 1016 Enum: variants, 1017 1017 } 1018 1018 1019 1019 - label := db.LabelDefinition{ 1019 1019 + label := models.LabelDefinition{ 1020 1020 Did: user.Did, 1021 1021 Rkey: tid.TID(), 1022 1022 Name: name, ··· 1396 1396 return 1397 1397 } 1398 1398 1399 1399 - defs := make(map[string]*db.LabelDefinition) 1399 1399 + defs := make(map[string]*models.LabelDefinition) 1400 1400 for _, l := range labelDefs { 1401 1401 defs[l.AtUri().String()] = &l 1402 1402 } ··· 1444 1444 return 1445 1445 } 1446 1446 1447 1447 - defs := make(map[string]*db.LabelDefinition) 1447 1447 + defs := make(map[string]*models.LabelDefinition) 1448 1448 for _, l := range labelDefs { 1449 1449 defs[l.AtUri().String()] = &l 1450 1450 } ··· 1895 1895 return 1896 1896 } 1897 1897 1898 1898 - defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", db.DefaultLabelDefs())) 1898 1898 + defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs())) 1899 1899 if err != nil { 1900 1900 log.Println("failed to fetch labels", err) 1901 1901 rp.pages.Error503(w)

+12 -12

appview/validator/label.go

··· 9 9 "github.com/bluesky-social/indigo/atproto/syntax" 10 10 "golang.org/x/exp/slices" 11 11 "tangled.sh/tangled.sh/core/api/tangled" 12 12 - "tangled.sh/tangled.sh/core/appview/db" 12 12 + "tangled.sh/tangled.sh/core/appview/models" 13 13 ) 14 14 15 15 var ( ··· 21 21 validScopes = []string{tangled.RepoIssueNSID, tangled.RepoPullNSID} 22 22 ) 23 23 24 24 - func (v *Validator) ValidateLabelDefinition(label *db.LabelDefinition) error { 24 24 + func (v *Validator) ValidateLabelDefinition(label *models.LabelDefinition) error { 25 25 if label.Name == "" { 26 26 return fmt.Errorf("label name is empty") 27 27 } ··· 95 95 return nil 96 96 } 97 97 98 98 - func (v *Validator) ValidateLabelOp(labelDef *db.LabelDefinition, labelOp *db.LabelOp) error { 98 98 + func (v *Validator) ValidateLabelOp(labelDef *models.LabelDefinition, labelOp *models.LabelOp) error { 99 99 if labelDef == nil { 100 100 return fmt.Errorf("label definition is required") 101 101 } ··· 108 108 return fmt.Errorf("operand key %q does not match label definition URI %q", labelOp.OperandKey, expectedKey) 109 109 } 110 110 111 111 - if labelOp.Operation != db.LabelOperationAdd && labelOp.Operation != db.LabelOperationDel { 111 111 + if labelOp.Operation != models.LabelOperationAdd && labelOp.Operation != models.LabelOperationDel { 112 112 return fmt.Errorf("invalid operation: %q (must be 'add' or 'del')", labelOp.Operation) 113 113 } 114 114 ··· 131 131 return nil 132 132 } 133 133 134 134 - func (v *Validator) validateOperandValue(labelDef *db.LabelDefinition, labelOp *db.LabelOp) error { 134 134 + func (v *Validator) validateOperandValue(labelDef *models.LabelDefinition, labelOp *models.LabelOp) error { 135 135 valueType := labelDef.ValueType 136 136 137 137 // this is permitted, it "unsets" a label 138 138 if labelOp.OperandValue == "" { 139 139 - labelOp.Operation = db.LabelOperationDel 139 139 + labelOp.Operation = models.LabelOperationDel 140 140 return nil 141 141 } 142 142 143 143 switch valueType.Type { 144 144 - case db.ConcreteTypeNull: 144 144 + case models.ConcreteTypeNull: 145 145 // For null type, value should be empty 146 146 if labelOp.OperandValue != "null" { 147 147 return fmt.Errorf("null type requires empty value, got %q", labelOp.OperandValue) 148 148 } 149 149 150 150 - case db.ConcreteTypeString: 150 150 + case models.ConcreteTypeString: 151 151 // For string type, validate enum constraints if present 152 152 if valueType.IsEnum() { 153 153 if !slices.Contains(valueType.Enum, labelOp.OperandValue) { ··· 156 156 } 157 157 158 158 switch valueType.Format { 159 159 - case db.ValueTypeFormatDid: 159 159 + case models.ValueTypeFormatDid: 160 160 id, err := v.resolver.ResolveIdent(context.Background(), labelOp.OperandValue) 161 161 if err != nil { 162 162 return fmt.Errorf("failed to resolve did/handle: %w", err) ··· 164 164 165 165 labelOp.OperandValue = id.DID.String() 166 166 167 167 - case db.ValueTypeFormatAny, "": 167 167 + case models.ValueTypeFormatAny, "": 168 168 default: 169 169 return fmt.Errorf("unsupported format constraint: %q", valueType.Format) 170 170 } 171 171 172 172 - case db.ConcreteTypeInt: 172 172 + case models.ConcreteTypeInt: 173 173 if labelOp.OperandValue == "" { 174 174 return fmt.Errorf("integer type requires non-empty value") 175 175 } ··· 183 183 } 184 184 } 185 185 186 186 - case db.ConcreteTypeBool: 186 186 + case models.ConcreteTypeBool: 187 187 if labelOp.OperandValue != "true" && labelOp.OperandValue != "false" { 188 188 return fmt.Errorf("boolean type requires value to be 'true' or 'false', got %q", labelOp.OperandValue) 189 189 }