forked from
tangled.org/core
Mirror of @tangled.org/core. Running on a Raspberry Pi Zero 2 (Please be gentle).
lexicons: rename, format and other required changes
authored by
nelind
and committed by
Anirudh Oppiliappan
5d021119
79ed2d0a
+115
-90
api/tangled/cbor_gen.go
api/tangled/cbor_gen.go
This is a binary file and will not be displayed.
api/tangled/issuecomment.go
api/tangled/issuecomment.go
This is a binary file and will not be displayed.
api/tangled/issuestate.go
api/tangled/issuestate.go
This is a binary file and will not be displayed.
api/tangled/knotmember.go
api/tangled/knotmember.go
This is a binary file and will not be displayed.
api/tangled/pullcomment.go
api/tangled/pullcomment.go
This is a binary file and will not be displayed.
api/tangled/pullstatus.go
api/tangled/pullstatus.go
This is a binary file and will not be displayed.
api/tangled/repoissue.go
api/tangled/repoissue.go
This is a binary file and will not be displayed.
api/tangled/repopull.go
api/tangled/repopull.go
This is a binary file and will not be displayed.
api/tangled/tangledpublicKey.go
api/tangled/tangledpublicKey.go
This is a binary file and will not be displayed.
api/tangled/tangledrepo.go
api/tangled/tangledrepo.go
This is a binary file and will not be displayed.
+2
-2
appview/pages/templates/knot.html
+2
-2
appview/pages/templates/knot.html
+3
-3
appview/settings/settings.go
+3
-3
appview/settings/settings.go
···
384
384
Rkey: rkey,
385
385
Record: &lexutil.LexiconTypeDecoder{
386
386
Val: &tangled.PublicKey{
387
-
Created: time.Now().Format(time.RFC3339),
388
-
Key: key,
389
-
Name: name,
387
+
CreatedAt: time.Now().Format(time.RFC3339),
388
+
Key: key,
389
+
Name: name,
390
390
}},
391
391
})
392
392
// invalid record
+2
-2
appview/state/pull.go
+2
-2
appview/state/pull.go
+15
-15
appview/state/repo.go
+15
-15
appview/state/repo.go
···
217
217
Knot: f.Knot,
218
218
Name: f.RepoName,
219
219
Owner: user.Did,
220
-
AddedAt: &f.AddedAt,
220
+
CreatedAt: f.CreatedAt,
221
221
Description: &newDescription,
222
222
},
223
223
},
···
851
851
RepoName string
852
852
RepoAt syntax.ATURI
853
853
Description string
854
-
AddedAt string
854
+
CreatedAt string
855
855
}
856
856
857
857
func (f *FullyResolvedRepo) OwnerDid() string {
···
1122
1122
Record: &lexutil.LexiconTypeDecoder{
1123
1123
Val: &tangled.RepoIssueState{
1124
1124
Issue: issue.IssueAt,
1125
-
State: &closed,
1125
+
State: closed,
1126
1126
},
1127
1127
},
1128
1128
})
···
1260
1260
Issue: issueAt,
1261
1261
CommentId: &commentIdInt64,
1262
1262
Owner: &ownerDid,
1263
-
Body: &body,
1264
-
CreatedAt: &createdAt,
1263
+
Body: body,
1264
+
CreatedAt: createdAt,
1265
1265
},
1266
1266
},
1267
1267
})
···
1429
1429
Issue: issueAt,
1430
1430
CommentId: &commentIdInt64,
1431
1431
Owner: &comment.OwnerDid,
1432
-
Body: &newBody,
1433
-
CreatedAt: &createdAt,
1432
+
Body: newBody,
1433
+
CreatedAt: createdAt,
1434
1434
},
1435
1435
},
1436
1436
})
···
1760
1760
} else {
1761
1761
uri = "https"
1762
1762
}
1763
-
sourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
1763
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
1764
1764
sourceAt := f.RepoAt.String()
1765
1765
1766
1766
rkey := appview.TID()
···
1786
1786
}
1787
1787
}()
1788
1788
1789
-
resp, err := client.ForkRepo(user.Did, sourceUrl, forkName)
1789
+
resp, err := client.ForkRepo(user.Did, forkSourceUrl, forkName)
1790
1790
if err != nil {
1791
1791
s.pages.Notice(w, "repo", "Failed to create repository on knot server.")
1792
1792
return
···
1804
1804
1805
1805
xrpcClient, _ := s.auth.AuthorizedClient(r)
1806
1806
1807
-
addedAt := time.Now().Format(time.RFC3339)
1807
+
createdAt := time.Now().Format(time.RFC3339)
1808
1808
atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{
1809
1809
Collection: tangled.RepoNSID,
1810
1810
Repo: user.Did,
1811
1811
Rkey: rkey,
1812
1812
Record: &lexutil.LexiconTypeDecoder{
1813
1813
Val: &tangled.Repo{
1814
-
Knot: repo.Knot,
1815
-
Name: repo.Name,
1816
-
AddedAt: &addedAt,
1817
-
Owner: user.Did,
1818
-
Source: &sourceAt,
1814
+
Knot: repo.Knot,
1815
+
Name: repo.Name,
1816
+
CreatedAt: createdAt,
1817
+
Owner: user.Did,
1818
+
Source: &sourceAt,
1819
1819
}},
1820
1820
})
1821
1821
if err != nil {
+1
-1
appview/state/repo_util.go
+1
-1
appview/state/repo_util.go
+16
-16
appview/state/state.go
+16
-16
appview/state/state.go
···
502
502
return
503
503
}
504
504
505
-
memberDid := r.FormValue("member")
506
-
if memberDid == "" {
505
+
subjectIdentifier := r.FormValue("subject")
506
+
if subjectIdentifier == "" {
507
507
http.Error(w, "malformed form", http.StatusBadRequest)
508
508
return
509
509
}
510
510
511
-
memberIdent, err := s.resolver.ResolveIdent(r.Context(), memberDid)
511
+
subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier)
512
512
if err != nil {
513
513
w.Write([]byte("failed to resolve member did to a handle"))
514
514
return
515
515
}
516
-
log.Printf("adding %s to %s\n", memberIdent.Handle.String(), domain)
516
+
log.Printf("adding %s to %s\n", subjectIdentity.Handle.String(), domain)
517
517
518
518
// announce this relation into the firehose, store into owners' pds
519
519
client, _ := s.auth.AuthorizedClient(r)
520
520
currentUser := s.auth.GetUser(r)
521
-
addedAt := time.Now().Format(time.RFC3339)
521
+
createdAt := time.Now().Format(time.RFC3339)
522
522
resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
523
523
Collection: tangled.KnotMemberNSID,
524
524
Repo: currentUser.Did,
525
525
Rkey: appview.TID(),
526
526
Record: &lexutil.LexiconTypeDecoder{
527
527
Val: &tangled.KnotMember{
528
-
Member: memberIdent.DID.String(),
529
-
Domain: domain,
530
-
AddedAt: &addedAt,
528
+
Subject: subjectIdentity.DID.String(),
529
+
Domain: domain,
530
+
CreatedAt: createdAt,
531
531
}},
532
532
})
533
533
···
550
550
return
551
551
}
552
552
553
-
ksResp, err := ksClient.AddMember(memberIdent.DID.String())
553
+
ksResp, err := ksClient.AddMember(subjectIdentity.DID.String())
554
554
if err != nil {
555
555
log.Printf("failed to make request to %s: %s", domain, err)
556
556
return
···
561
561
return
562
562
}
563
563
564
-
err = s.enforcer.AddMember(domain, memberIdent.DID.String())
564
+
err = s.enforcer.AddMember(domain, subjectIdentity.DID.String())
565
565
if err != nil {
566
566
w.Write([]byte(fmt.Sprint("failed to add member: ", err)))
567
567
return
568
568
}
569
569
570
-
w.Write([]byte(fmt.Sprint("added member: ", memberIdent.Handle.String())))
570
+
w.Write([]byte(fmt.Sprint("added member: ", subjectIdentity.Handle.String())))
571
571
}
572
572
573
573
func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) {
···
657
657
658
658
xrpcClient, _ := s.auth.AuthorizedClient(r)
659
659
660
-
addedAt := time.Now().Format(time.RFC3339)
660
+
createdAt := time.Now().Format(time.RFC3339)
661
661
atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{
662
662
Collection: tangled.RepoNSID,
663
663
Repo: user.Did,
664
664
Rkey: rkey,
665
665
Record: &lexutil.LexiconTypeDecoder{
666
666
Val: &tangled.Repo{
667
-
Knot: repo.Knot,
668
-
Name: repoName,
669
-
AddedAt: &addedAt,
670
-
Owner: user.Did,
667
+
Knot: repo.Knot,
668
+
Name: repoName,
669
+
CreatedAt: createdAt,
670
+
Owner: user.Did,
671
671
}},
672
672
})
673
673
if err != nil {
+9
-9
knotserver/db/pubkeys.go
+9
-9
knotserver/db/pubkeys.go
···
23
23
Did: did,
24
24
}
25
25
pk.Key = record["key"]
26
-
pk.Created = record["created"]
26
+
pk.CreatedAt = record["createdAt"]
27
27
28
28
return d.AddPublicKey(pk)
29
29
}
30
30
31
31
func (d *DB) AddPublicKey(pk PublicKey) error {
32
-
if pk.Created == "" {
33
-
pk.Created = time.Now().Format(time.RFC3339)
32
+
if pk.CreatedAt == "" {
33
+
pk.CreatedAt = time.Now().Format(time.RFC3339)
34
34
}
35
35
36
36
query := `insert or ignore into public_keys (did, key, created) values (?, ?, ?)`
37
-
_, err := d.db.Exec(query, pk.Did, pk.Key, pk.Created)
37
+
_, err := d.db.Exec(query, pk.Did, pk.Key, pk.CreatedAt)
38
38
return err
39
39
}
40
40
···
46
46
47
47
func (pk *PublicKey) JSON() map[string]any {
48
48
return map[string]any{
49
-
"did": pk.Did,
50
-
"key": pk.Key,
51
-
"created": pk.Created,
49
+
"did": pk.Did,
50
+
"key": pk.Key,
51
+
"createdAt": pk.CreatedAt,
52
52
}
53
53
}
54
54
···
63
63
64
64
for rows.Next() {
65
65
var publicKey PublicKey
66
-
if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.Created); err != nil {
66
+
if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.CreatedAt); err != nil {
67
67
return nil, err
68
68
}
69
69
keys = append(keys, publicKey)
···
87
87
88
88
for rows.Next() {
89
89
var publicKey PublicKey
90
-
if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.Created); err != nil {
90
+
if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.CreatedAt); err != nil {
91
91
return nil, err
92
92
}
93
93
keys = append(keys, publicKey)
+2
-2
knotserver/jetstream.go
+2
-2
knotserver/jetstream.go
···
43
43
return fmt.Errorf("failed to enforce permissions: %w", err)
44
44
}
45
45
46
-
if err := h.e.AddMember(ThisServer, record.Member); err != nil {
46
+
if err := h.e.AddMember(ThisServer, record.Subject); err != nil {
47
47
l.Error("failed to add member", "error", err)
48
48
return fmt.Errorf("failed to add member: %w", err)
49
49
}
50
-
l.Info("added member from firehose", "member", record.Member)
50
+
l.Info("added member from firehose", "member", record.Subject)
51
51
52
52
if err := h.db.AddDid(did); err != nil {
53
53
l.Error("failed to add did", "error", err)
+6
-7
lexicons/follow.json
+6
-7
lexicons/follow.json
···
10
10
"record": {
11
11
"type": "object",
12
12
"required": [
13
-
"createdAt",
14
-
"subject"
13
+
"subject",
14
+
"createdAt"
15
15
],
16
16
"properties": {
17
-
"createdAt": {
18
-
"type": "string",
19
-
"format": "datetime"
20
-
},
21
17
"subject": {
22
18
"type": "string",
23
19
"format": "did"
20
+
},
21
+
"createdAt": {
22
+
"type": "string",
23
+
"format": "datetime"
24
24
}
25
25
}
26
26
}
27
27
}
28
28
}
29
29
}
30
-
+5
-1
lexicons/issue/comment.json
+5
-1
lexicons/issue/comment.json
+7
-1
lexicons/issue/issue.json
+7
-1
lexicons/issue/issue.json
+4
-1
lexicons/issue/state.json
+4
-1
lexicons/issue/state.json
+5
-4
lexicons/member.json
+5
-4
lexicons/member.json
···
10
10
"record": {
11
11
"type": "object",
12
12
"required": [
13
-
"member",
14
-
"domain"
13
+
"subject",
14
+
"domain",
15
+
"createdAt"
15
16
],
16
17
"properties": {
17
-
"member": {
18
+
"subject": {
18
19
"type": "string",
19
20
"format": "did"
20
21
},
···
23
22
"type": "string",
24
23
"description": "domain that this member now belongs to"
25
24
},
26
-
"addedAt": {
25
+
"createdAt": {
27
26
"type": "string",
28
27
"format": "datetime"
29
28
}
+2
-3
lexicons/publicKey.json
+2
-3
lexicons/publicKey.json
···
12
12
"required": [
13
13
"key",
14
14
"name",
15
-
"created"
15
+
"createdAt"
16
16
],
17
17
"properties": {
18
18
"key": {
19
19
"type": "string",
20
20
"maxLength": 4096,
21
-
"maxGraphemes": 4096,
22
21
"description": "public key contents"
23
22
},
24
23
"name": {
···
25
26
"format": "string",
26
27
"description": "human-readable name for this key"
27
28
},
28
-
"created": {
29
+
"createdAt": {
29
30
"type": "string",
30
31
"format": "datetime",
31
32
"description": "key upload timestamp"
+5
-1
lexicons/pulls/comment.json
+5
-1
lexicons/pulls/comment.json
+9
-6
lexicons/pulls/pull.json
+9
-6
lexicons/pulls/pull.json
···
14
14
"targetBranch",
15
15
"pullId",
16
16
"title",
17
-
"patch"
17
+
"patch",
18
+
"createdAt"
18
19
],
19
20
"properties": {
20
21
"targetRepo": {
···
34
33
"body": {
35
34
"type": "string"
36
35
},
37
-
"createdAt": {
38
-
"type": "string",
39
-
"format": "datetime"
40
-
},
41
36
"patch": {
42
37
"type": "string"
43
38
},
44
39
"source": {
45
40
"type": "ref",
46
41
"ref": "#source"
42
+
},
43
+
"createdAt": {
44
+
"type": "string",
45
+
"format": "datetime"
47
46
}
48
47
}
49
48
}
50
49
},
51
50
"source": {
52
51
"type": "object",
53
-
"required": ["branch"],
52
+
"required": [
53
+
"branch"
54
+
],
54
55
"properties": {
55
56
"branch": {
56
57
"type": "string"
+4
-1
lexicons/pulls/state.json
+4
-1
lexicons/pulls/state.json
+12
-7
lexicons/repo.json
+12
-7
lexicons/repo.json
···
9
9
"key": "tid",
10
10
"record": {
11
11
"type": "object",
12
-
"required": ["name", "knot", "owner"],
12
+
"required": [
13
+
"name",
14
+
"knot",
15
+
"owner",
16
+
"createdAt"
17
+
],
13
18
"properties": {
14
19
"name": {
15
20
"type": "string",
···
28
23
"type": "string",
29
24
"description": "knot where the repo was created"
30
25
},
31
-
"addedAt": {
32
-
"type": "string",
33
-
"format": "datetime"
34
-
},
35
26
"description": {
36
27
"type": "string",
37
28
"format": "datetime",
38
-
"minLength": 1,
39
-
"maxLength": 140
29
+
"minGraphemes": 1,
30
+
"maxGraphemes": 140
40
31
},
41
32
"source": {
42
33
"type": "string",
43
34
"format": "uri",
44
35
"description": "source of the repo"
36
+
},
37
+
"createdAt": {
38
+
"type": "string",
39
+
"format": "datetime"
45
40
}
46
41
}
47
42
}
+6
-8
lexicons/star.json
+6
-8
lexicons/star.json
···
10
10
"record": {
11
11
"type": "object",
12
12
"required": [
13
-
"createdAt",
14
-
"subject"
13
+
"subject",
14
+
"createdAt"
15
15
],
16
16
"properties": {
17
-
"createdAt": {
18
-
"type": "string",
19
-
"format": "datetime"
20
-
},
21
17
"subject": {
22
18
"type": "string",
23
19
"format": "at-uri"
20
+
},
21
+
"createdAt": {
22
+
"type": "string",
23
+
"format": "datetime"
24
24
}
25
25
}
26
26
}
27
27
}
28
28
}
29
29
}
30
-
31
-