alice.pds.demo.boltless.dev
This repository has no description
appview/labels: change scope to be a list of NSIDs
Signed-off-by: oppiliappan <me@oppi.li>
author
oppiliappan
date
(Sep 23, 2025, 11:46 AM +0100)
commit
68d49b36
68d49b3620135baed0ce0e2a2ed6eef760aa8dd3
parent
f1dba362
f1dba3622aae7fb6532f19f2c441c5f242dea16f
change-id
yuoqkqmv
yuoqkqmvvxzwprnkynnoqrklnlpyttmy
+195
-35
+13
-8
appview/db/db.go
+13
-8
appview/db/db.go
···
483
483
)),
484
484
value_format text not null default "any",
485
485
value_enum text, -- comma separated list
486
-
scope text not null,
486
+
scope text not null, -- comma separated list of nsid
487
487
color text,
488
488
multiple integer not null default 0,
489
489
created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
···
996
996
}
997
997
}
998
998
999
-
func FilterEq(key string, arg any) filter { return newFilter(key, "=", arg) }
1000
-
func FilterNotEq(key string, arg any) filter { return newFilter(key, "<>", arg) }
1001
-
func FilterGte(key string, arg any) filter { return newFilter(key, ">=", arg) }
1002
-
func FilterLte(key string, arg any) filter { return newFilter(key, "<=", arg) }
1003
-
func FilterIs(key string, arg any) filter { return newFilter(key, "is", arg) }
1004
-
func FilterIsNot(key string, arg any) filter { return newFilter(key, "is not", arg) }
1005
-
func FilterIn(key string, arg any) filter { return newFilter(key, "in", arg) }
999
+
func FilterEq(key string, arg any) filter { return newFilter(key, "=", arg) }
1000
+
func FilterNotEq(key string, arg any) filter { return newFilter(key, "<>", arg) }
1001
+
func FilterGte(key string, arg any) filter { return newFilter(key, ">=", arg) }
1002
+
func FilterLte(key string, arg any) filter { return newFilter(key, "<=", arg) }
1003
+
func FilterIs(key string, arg any) filter { return newFilter(key, "is", arg) }
1004
+
func FilterIsNot(key string, arg any) filter { return newFilter(key, "is not", arg) }
1005
+
func FilterIn(key string, arg any) filter { return newFilter(key, "in", arg) }
1006
+
func FilterLike(key string, arg any) filter { return newFilter(key, "like", arg) }
1007
+
func FilterNotLike(key string, arg any) filter { return newFilter(key, "not like", arg) }
1008
+
func FilterContains(key string, arg any) filter {
1009
+
return newFilter(key, "like", fmt.Sprintf("%%%v%%", arg))
1010
+
}
1006
1011
1007
1012
func (f filter) Condition() string {
1008
1013
rv := reflect.ValueOf(f.arg)
+1
-1
appview/issues/issues.go
+1
-1
appview/issues/issues.go
+145
-14
appview/repo/repo.go
+145
-14
appview/repo/repo.go
···
966
966
rp.pages.HxRefresh(w)
967
967
}
968
968
969
-
func (rp *Repo) AddLabel(w http.ResponseWriter, r *http.Request) {
969
+
func (rp *Repo) AddLabelDef(w http.ResponseWriter, r *http.Request) {
970
970
user := rp.oauth.GetUser(r)
971
971
l := rp.logger.With("handler", "AddLabel")
972
972
l = l.With("did", user.Did)
···
989
989
concreteType := r.FormValue("valueType")
990
990
valueFormat := r.FormValue("valueFormat")
991
991
enumValues := r.FormValue("enumValues")
992
-
scope := r.FormValue("scope")
992
+
scope := r.Form["scope"]
993
993
color := r.FormValue("color")
994
994
multiple := r.FormValue("multiple") == "true"
995
995
···
1000
1000
}
1001
1001
}
1002
1002
1003
+
if concreteType == "" {
1004
+
concreteType = "null"
1005
+
}
1006
+
1003
1007
format := db.ValueTypeFormatAny
1004
1008
if valueFormat == "did" {
1005
1009
format = db.ValueTypeFormatDid
···
1016
1020
Rkey: tid.TID(),
1017
1021
Name: name,
1018
1022
ValueType: valueType,
1019
-
Scope: syntax.NSID(scope),
1023
+
Scope: scope,
1020
1024
Color: &color,
1021
1025
Multiple: multiple,
1022
1026
Created: time.Now(),
···
1072
1076
Val: &repoRecord,
1073
1077
},
1074
1078
})
1079
+
if err != nil {
1080
+
fail("Failed to update labels for repo.", err)
1081
+
return
1082
+
}
1075
1083
1076
1084
tx, err := rp.db.BeginTx(r.Context(), nil)
1077
1085
if err != nil {
···
1118
1126
rp.pages.HxRefresh(w)
1119
1127
}
1120
1128
1121
-
func (rp *Repo) DeleteLabel(w http.ResponseWriter, r *http.Request) {
1129
+
func (rp *Repo) DeleteLabelDef(w http.ResponseWriter, r *http.Request) {
1122
1130
user := rp.oauth.GetUser(r)
1123
1131
l := rp.logger.With("handler", "DeleteLabel")
1124
1132
l = l.With("did", user.Did)
···
1229
1237
1230
1238
func (rp *Repo) SubscribeLabel(w http.ResponseWriter, r *http.Request) {
1231
1239
user := rp.oauth.GetUser(r)
1232
-
l := rp.logger.With("handler", "DeleteLabel")
1240
+
l := rp.logger.With("handler", "SubscribeLabel")
1233
1241
l = l.With("did", user.Did)
1234
1242
l = l.With("handle", user.Handle)
1235
1243
···
1239
1247
return
1240
1248
}
1241
1249
1242
-
errorId := "label-operation"
1250
+
errorId := "default-label-operation"
1243
1251
fail := func(msg string, err error) {
1244
1252
l.Error(msg, "err", err)
1245
1253
rp.pages.Notice(w, errorId, msg)
···
1292
1300
1293
1301
func (rp *Repo) UnsubscribeLabel(w http.ResponseWriter, r *http.Request) {
1294
1302
user := rp.oauth.GetUser(r)
1295
-
l := rp.logger.With("handler", "DeleteLabel")
1303
+
l := rp.logger.With("handler", "UnsubscribeLabel")
1296
1304
l = l.With("did", user.Did)
1297
1305
l = l.With("handle", user.Handle)
1298
1306
···
1302
1310
return
1303
1311
}
1304
1312
1305
-
errorId := "label-operation"
1313
+
errorId := "default-label-operation"
1306
1314
fail := func(msg string, err error) {
1307
1315
l.Error(msg, "err", err)
1308
1316
rp.pages.Notice(w, errorId, msg)
···
1361
1369
rp.pages.HxRefresh(w)
1362
1370
}
1363
1371
1372
+
func (rp *Repo) LabelPanel(w http.ResponseWriter, r *http.Request) {
1373
+
l := rp.logger.With("handler", "LabelPanel")
1374
+
1375
+
f, err := rp.repoResolver.Resolve(r)
1376
+
if err != nil {
1377
+
l.Error("failed to get repo and knot", "err", err)
1378
+
return
1379
+
}
1380
+
1381
+
subjectStr := r.FormValue("subject")
1382
+
subject, err := syntax.ParseATURI(subjectStr)
1383
+
if err != nil {
1384
+
l.Error("failed to get repo and knot", "err", err)
1385
+
return
1386
+
}
1387
+
1388
+
labelDefs, err := db.GetLabelDefinitions(
1389
+
rp.db,
1390
+
db.FilterIn("at_uri", f.Repo.Labels),
1391
+
db.FilterContains("scope", subject.Collection().String()),
1392
+
)
1393
+
if err != nil {
1394
+
log.Println("failed to fetch label defs", err)
1395
+
return
1396
+
}
1397
+
1398
+
defs := make(map[string]*db.LabelDefinition)
1399
+
for _, l := range labelDefs {
1400
+
defs[l.AtUri().String()] = &l
1401
+
}
1402
+
1403
+
states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))
1404
+
if err != nil {
1405
+
log.Println("failed to build label state", err)
1406
+
return
1407
+
}
1408
+
state := states[subject]
1409
+
1410
+
user := rp.oauth.GetUser(r)
1411
+
rp.pages.LabelPanel(w, pages.LabelPanelParams{
1412
+
LoggedInUser: user,
1413
+
RepoInfo: f.RepoInfo(user),
1414
+
Defs: defs,
1415
+
Subject: subject.String(),
1416
+
State: state,
1417
+
})
1418
+
}
1419
+
1420
+
func (rp *Repo) EditLabelPanel(w http.ResponseWriter, r *http.Request) {
1421
+
l := rp.logger.With("handler", "EditLabelPanel")
1422
+
1423
+
f, err := rp.repoResolver.Resolve(r)
1424
+
if err != nil {
1425
+
l.Error("failed to get repo and knot", "err", err)
1426
+
return
1427
+
}
1428
+
1429
+
subjectStr := r.FormValue("subject")
1430
+
subject, err := syntax.ParseATURI(subjectStr)
1431
+
if err != nil {
1432
+
l.Error("failed to get repo and knot", "err", err)
1433
+
return
1434
+
}
1435
+
1436
+
labelDefs, err := db.GetLabelDefinitions(
1437
+
rp.db,
1438
+
db.FilterIn("at_uri", f.Repo.Labels),
1439
+
db.FilterContains("scope", subject.Collection().String()),
1440
+
)
1441
+
if err != nil {
1442
+
log.Println("failed to fetch labels", err)
1443
+
return
1444
+
}
1445
+
1446
+
defs := make(map[string]*db.LabelDefinition)
1447
+
for _, l := range labelDefs {
1448
+
defs[l.AtUri().String()] = &l
1449
+
}
1450
+
1451
+
states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))
1452
+
if err != nil {
1453
+
log.Println("failed to build label state", err)
1454
+
return
1455
+
}
1456
+
state := states[subject]
1457
+
1458
+
user := rp.oauth.GetUser(r)
1459
+
rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{
1460
+
LoggedInUser: user,
1461
+
RepoInfo: f.RepoInfo(user),
1462
+
Defs: defs,
1463
+
Subject: subject.String(),
1464
+
State: state,
1465
+
})
1466
+
}
1467
+
1364
1468
func (rp *Repo) AddCollaborator(w http.ResponseWriter, r *http.Request) {
1365
1469
user := rp.oauth.GetUser(r)
1366
1470
l := rp.logger.With("handler", "AddCollaborator")
···
1790
1894
return
1791
1895
}
1792
1896
1897
+
defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", db.DefaultLabelDefs()))
1898
+
if err != nil {
1899
+
log.Println("failed to fetch labels", err)
1900
+
rp.pages.Error503(w)
1901
+
return
1902
+
}
1903
+
1793
1904
labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
1794
1905
if err != nil {
1795
1906
log.Println("failed to fetch labels", err)
1796
1907
rp.pages.Error503(w)
1797
1908
return
1798
1909
}
1910
+
// remove default labels from the labels list, if present
1911
+
defaultLabelMap := make(map[string]bool)
1912
+
for _, dl := range defaultLabels {
1913
+
defaultLabelMap[dl.AtUri().String()] = true
1914
+
}
1915
+
n := 0
1916
+
for _, l := range labels {
1917
+
if !defaultLabelMap[l.AtUri().String()] {
1918
+
labels[n] = l
1919
+
n++
1920
+
}
1921
+
}
1922
+
labels = labels[:n]
1923
+
1924
+
subscribedLabels := make(map[string]struct{})
1925
+
for _, l := range f.Repo.Labels {
1926
+
subscribedLabels[l] = struct{}{}
1927
+
}
1799
1928
1800
1929
rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{
1801
-
LoggedInUser: user,
1802
-
RepoInfo: f.RepoInfo(user),
1803
-
Branches: result.Branches,
1804
-
Labels: labels,
1805
-
Tabs: settingsTabs,
1806
-
Tab: "general",
1930
+
LoggedInUser: user,
1931
+
RepoInfo: f.RepoInfo(user),
1932
+
Branches: result.Branches,
1933
+
Labels: labels,
1934
+
DefaultLabels: defaultLabels,
1935
+
SubscribedLabels: subscribedLabels,
1936
+
Tabs: settingsTabs,
1937
+
Tab: "general",
1807
1938
})
1808
1939
}
1809
1940
+36
-12
appview/validator/label.go
+36
-12
appview/validator/label.go
···
18
18
// Color should be a valid hex color
19
19
colorRegex = regexp.MustCompile(`^#[a-fA-F0-9]{6}$`)
20
20
// You can only label issues and pulls presently
21
-
validScopes = []syntax.NSID{tangled.RepoIssueNSID, tangled.RepoPullNSID}
21
+
validScopes = []string{tangled.RepoIssueNSID, tangled.RepoPullNSID}
22
22
)
23
23
24
24
func (v *Validator) ValidateLabelDefinition(label *db.LabelDefinition) error {
···
36
36
}
37
37
38
38
if !label.ValueType.IsConcreteType() {
39
-
return fmt.Errorf("invalid value type: %q (must be one of: null, boolean, integer, string)", label.ValueType)
39
+
return fmt.Errorf("invalid value type: %q (must be one of: null, boolean, integer, string)", label.ValueType.Type)
40
40
}
41
41
42
-
if label.ValueType.IsNull() && label.ValueType.IsEnumType() {
42
+
// null type checks: cannot be enums, multiple or explicit format
43
+
if label.ValueType.IsNull() && label.ValueType.IsEnum() {
43
44
return fmt.Errorf("null type cannot be used in conjunction with enum type")
44
45
}
46
+
if label.ValueType.IsNull() && label.Multiple {
47
+
return fmt.Errorf("null type labels cannot be multiple")
48
+
}
49
+
if label.ValueType.IsNull() && !label.ValueType.IsAnyFormat() {
50
+
return fmt.Errorf("format cannot be used in conjunction with null type")
51
+
}
52
+
53
+
// format checks: cannot be used with enum, or integers
54
+
if !label.ValueType.IsAnyFormat() && label.ValueType.IsEnum() {
55
+
return fmt.Errorf("enum types cannot be used in conjunction with format specification")
56
+
}
57
+
58
+
if !label.ValueType.IsAnyFormat() && !label.ValueType.IsString() {
59
+
return fmt.Errorf("format specifications are only permitted on string types")
60
+
}
45
61
46
62
// validate scope (nsid format)
47
-
if label.Scope == "" {
63
+
if label.Scope == nil {
48
64
return fmt.Errorf("scope is required")
49
65
}
50
-
if _, err := syntax.ParseNSID(string(label.Scope)); err != nil {
51
-
return fmt.Errorf("failed to parse scope: %w", err)
52
-
}
53
-
if !slices.Contains(validScopes, label.Scope) {
54
-
return fmt.Errorf("invalid scope: scope must be one of %q", validScopes)
66
+
for _, s := range label.Scope {
67
+
if _, err := syntax.ParseNSID(s); err != nil {
68
+
return fmt.Errorf("failed to parse scope: %w", err)
69
+
}
70
+
if !slices.Contains(validScopes, s) {
71
+
return fmt.Errorf("invalid scope: scope must be present in %q", validScopes)
72
+
}
55
73
}
56
74
57
75
// validate color if provided
···
116
134
func (v *Validator) validateOperandValue(labelDef *db.LabelDefinition, labelOp *db.LabelOp) error {
117
135
valueType := labelDef.ValueType
118
136
137
+
// this is permitted, it "unsets" a label
138
+
if labelOp.OperandValue == "" {
139
+
labelOp.Operation = db.LabelOperationDel
140
+
return nil
141
+
}
142
+
119
143
switch valueType.Type {
120
144
case db.ConcreteTypeNull:
121
145
// For null type, value should be empty
···
125
149
126
150
case db.ConcreteTypeString:
127
151
// For string type, validate enum constraints if present
128
-
if valueType.IsEnumType() {
152
+
if valueType.IsEnum() {
129
153
if !slices.Contains(valueType.Enum, labelOp.OperandValue) {
130
154
return fmt.Errorf("value %q is not in allowed enum values %v", labelOp.OperandValue, valueType.Enum)
131
155
}
···
153
177
return fmt.Errorf("value %q is not a valid integer", labelOp.OperandValue)
154
178
}
155
179
156
-
if valueType.IsEnumType() {
180
+
if valueType.IsEnum() {
157
181
if !slices.Contains(valueType.Enum, labelOp.OperandValue) {
158
182
return fmt.Errorf("value %q is not in allowed enum values %v", labelOp.OperandValue, valueType.Enum)
159
183
}
···
165
189
}
166
190
167
191
// validate enum constraints if present (though uncommon for booleans)
168
-
if valueType.IsEnumType() {
192
+
if valueType.IsEnum() {
169
193
if !slices.Contains(valueType.Enum, labelOp.OperandValue) {
170
194
return fmt.Errorf("value %q is not in allowed enum values %v", labelOp.OperandValue, valueType.Enum)
171
195
}