forked from
tangled.org/core
This repository has no description
lexicon: add sh.tangled.knot.policy (#3)
* lexicon: add sh.tangled.knot.policy
* i ran lexgen
* i ran nix fmt
---------
Co-authored-by: Akshay <nerdy@peppe.rs>
author
Anirudh Oppiliappan
co-author
Akshay
committer
GitHub
date
(Feb 3, 2025, 4:08 PM +0200)
commit
92fc5459
92fc5459d0cda5f7d3e20421808a666a6d4afb86
parent
c3fae1b1
c3fae1b14cc2ee8f062547f3b6400757730afd85
+319
-24
+232
api/tangled/cbor_gen.go
+232
api/tangled/cbor_gen.go
···
216
216
217
217
return nil
218
218
}
219
+
func (t *KnotPolicy) MarshalCBOR(w io.Writer) error {
220
+
if t == nil {
221
+
_, err := w.Write(cbg.CborNull)
222
+
return err
223
+
}
224
+
225
+
cw := cbg.NewCborWriter(w)
226
+
227
+
if _, err := cw.Write([]byte{165}); err != nil {
228
+
return err
229
+
}
230
+
231
+
// t.LexiconTypeID (string) (string)
232
+
if len("$type") > 1000000 {
233
+
return xerrors.Errorf("Value in field \"$type\" was too long")
234
+
}
235
+
236
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
237
+
return err
238
+
}
239
+
if _, err := cw.WriteString(string("$type")); err != nil {
240
+
return err
241
+
}
242
+
243
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.policy"))); err != nil {
244
+
return err
245
+
}
246
+
if _, err := cw.WriteString(string("sh.tangled.knot.policy")); err != nil {
247
+
return err
248
+
}
249
+
250
+
// t.Action (string) (string)
251
+
if len("action") > 1000000 {
252
+
return xerrors.Errorf("Value in field \"action\" was too long")
253
+
}
254
+
255
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
256
+
return err
257
+
}
258
+
if _, err := cw.WriteString(string("action")); err != nil {
259
+
return err
260
+
}
261
+
262
+
if len(t.Action) > 1000000 {
263
+
return xerrors.Errorf("Value in field t.Action was too long")
264
+
}
265
+
266
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
267
+
return err
268
+
}
269
+
if _, err := cw.WriteString(string(t.Action)); err != nil {
270
+
return err
271
+
}
272
+
273
+
// t.Domain (string) (string)
274
+
if len("domain") > 1000000 {
275
+
return xerrors.Errorf("Value in field \"domain\" was too long")
276
+
}
277
+
278
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
279
+
return err
280
+
}
281
+
if _, err := cw.WriteString(string("domain")); err != nil {
282
+
return err
283
+
}
284
+
285
+
if len(t.Domain) > 1000000 {
286
+
return xerrors.Errorf("Value in field t.Domain was too long")
287
+
}
288
+
289
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
290
+
return err
291
+
}
292
+
if _, err := cw.WriteString(string(t.Domain)); err != nil {
293
+
return err
294
+
}
295
+
296
+
// t.Object (string) (string)
297
+
if len("object") > 1000000 {
298
+
return xerrors.Errorf("Value in field \"object\" was too long")
299
+
}
300
+
301
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("object"))); err != nil {
302
+
return err
303
+
}
304
+
if _, err := cw.WriteString(string("object")); err != nil {
305
+
return err
306
+
}
307
+
308
+
if len(t.Object) > 1000000 {
309
+
return xerrors.Errorf("Value in field t.Object was too long")
310
+
}
311
+
312
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Object))); err != nil {
313
+
return err
314
+
}
315
+
if _, err := cw.WriteString(string(t.Object)); err != nil {
316
+
return err
317
+
}
318
+
319
+
// t.Subject (string) (string)
320
+
if len("subject") > 1000000 {
321
+
return xerrors.Errorf("Value in field \"subject\" was too long")
322
+
}
323
+
324
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
325
+
return err
326
+
}
327
+
if _, err := cw.WriteString(string("subject")); err != nil {
328
+
return err
329
+
}
330
+
331
+
if len(t.Subject) > 1000000 {
332
+
return xerrors.Errorf("Value in field t.Subject was too long")
333
+
}
334
+
335
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
336
+
return err
337
+
}
338
+
if _, err := cw.WriteString(string(t.Subject)); err != nil {
339
+
return err
340
+
}
341
+
return nil
342
+
}
343
+
344
+
func (t *KnotPolicy) UnmarshalCBOR(r io.Reader) (err error) {
345
+
*t = KnotPolicy{}
346
+
347
+
cr := cbg.NewCborReader(r)
348
+
349
+
maj, extra, err := cr.ReadHeader()
350
+
if err != nil {
351
+
return err
352
+
}
353
+
defer func() {
354
+
if err == io.EOF {
355
+
err = io.ErrUnexpectedEOF
356
+
}
357
+
}()
358
+
359
+
if maj != cbg.MajMap {
360
+
return fmt.Errorf("cbor input should be of type map")
361
+
}
362
+
363
+
if extra > cbg.MaxLength {
364
+
return fmt.Errorf("KnotPolicy: map struct too large (%d)", extra)
365
+
}
366
+
367
+
n := extra
368
+
369
+
nameBuf := make([]byte, 7)
370
+
for i := uint64(0); i < n; i++ {
371
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
372
+
if err != nil {
373
+
return err
374
+
}
375
+
376
+
if !ok {
377
+
// Field doesn't exist on this type, so ignore it
378
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
379
+
return err
380
+
}
381
+
continue
382
+
}
383
+
384
+
switch string(nameBuf[:nameLen]) {
385
+
// t.LexiconTypeID (string) (string)
386
+
case "$type":
387
+
388
+
{
389
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
390
+
if err != nil {
391
+
return err
392
+
}
393
+
394
+
t.LexiconTypeID = string(sval)
395
+
}
396
+
// t.Action (string) (string)
397
+
case "action":
398
+
399
+
{
400
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
401
+
if err != nil {
402
+
return err
403
+
}
404
+
405
+
t.Action = string(sval)
406
+
}
407
+
// t.Domain (string) (string)
408
+
case "domain":
409
+
410
+
{
411
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
412
+
if err != nil {
413
+
return err
414
+
}
415
+
416
+
t.Domain = string(sval)
417
+
}
418
+
// t.Object (string) (string)
419
+
case "object":
420
+
421
+
{
422
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
423
+
if err != nil {
424
+
return err
425
+
}
426
+
427
+
t.Object = string(sval)
428
+
}
429
+
// t.Subject (string) (string)
430
+
case "subject":
431
+
432
+
{
433
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
434
+
if err != nil {
435
+
return err
436
+
}
437
+
438
+
t.Subject = string(sval)
439
+
}
440
+
441
+
default:
442
+
// Field doesn't exist on this type, so ignore it
443
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
444
+
return err
445
+
}
446
+
}
447
+
}
448
+
449
+
return nil
450
+
}
+29
api/tangled/knotpolicy.go
+29
api/tangled/knotpolicy.go
···
1
+
// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
2
+
3
+
package tangled
4
+
5
+
// schema: sh.tangled.knot.policy
6
+
7
+
import (
8
+
"github.com/bluesky-social/indigo/lex/util"
9
+
)
10
+
11
+
const (
12
+
KnotPolicyNSID = "sh.tangled.knot.policy"
13
+
)
14
+
15
+
func init() {
16
+
util.RegisterType("sh.tangled.knot.policy", &KnotPolicy{})
17
+
} //
18
+
// RECORDTYPE: KnotPolicy
19
+
type KnotPolicy struct {
20
+
LexiconTypeID string `json:"$type,const=sh.tangled.knot.policy" cborgen:"$type,const=sh.tangled.knot.policy"`
21
+
// action: action associated with the key
22
+
Action string `json:"action" cborgen:"action"`
23
+
// domain: domain of the key
24
+
Domain string `json:"domain" cborgen:"domain"`
25
+
// object: object associated with the key
26
+
Object string `json:"object" cborgen:"object"`
27
+
// subject: subject of the key
28
+
Subject string `json:"subject" cborgen:"subject"`
29
+
}
+1
cmd/gen.go
+1
cmd/gen.go
+6
-6
flake.lock
+6
-6
flake.lock
···
3
3
"indigo": {
4
4
"flake": false,
5
5
"locked": {
6
-
"lastModified": 1738055559,
7
-
"narHash": "sha256-wsey8gs825Tm9Q3zITqg4B6TmHCDuV9vyQlXEnD/7/I=",
6
+
"lastModified": 1738491661,
7
+
"narHash": "sha256-+njDigkvjH4XmXZMog5Mp0K4x9mamHX6gSGJCZB9mE4=",
8
8
"owner": "oppiliappan",
9
9
"repo": "indigo",
10
-
"rev": "9b475b7509c21b98b6ccd97c6d3f2e8d8ea3eae0",
10
+
"rev": "feb802f02a462ac0a6392ffc3e40b0529f0cdf71",
11
11
"type": "github"
12
12
},
13
13
"original": {
···
18
18
},
19
19
"nixpkgs": {
20
20
"locked": {
21
-
"lastModified": 1737753923,
22
-
"narHash": "sha256-O30NErrRU1AMlHoIbsKWs57Lvi8IgGvs+2ZtkTtq7b8=",
21
+
"lastModified": 1738589849,
22
+
"narHash": "sha256-YbBrqtYjo7HB+gA2WKN2jWxj0H2e5dBwYrbWeIyirAc=",
23
23
"owner": "nixos",
24
24
"repo": "nixpkgs",
25
-
"rev": "a019ad96aa3710cd05710839f153f58c0325d486",
25
+
"rev": "e4a4b2cf12d2c4c15dd6387c74421999095c49ad",
26
26
"type": "github"
27
27
},
28
28
"original": {
+17
-18
flake.nix
+17
-18
flake.nix
···
29
29
version = "0.1.0";
30
30
src = indigo;
31
31
subPackage = ["cmd/lexgen"];
32
-
vendorHash = null;
32
+
vendorHash = "sha256-pGc29fgJFq8LP7n/pY1cv6ExZl88PAeFqIbFEhB3xXs=";
33
33
doCheck = false;
34
34
};
35
35
};
···
53
53
];
54
54
};
55
55
});
56
-
apps = forAllSystems (system:
57
-
let
58
-
pkgs = nixpkgsFor."${system}";
59
-
air-watcher = name: pkgs.writeShellScriptBin "run"
60
-
''
61
-
${pkgs.air}/bin/air -c /dev/null -build.cmd "${pkgs.go}/bin/go build -o ./out/${name}.out ./cmd/${name}/main.go" -build.bin "./out/${name}.out"
62
-
'';
63
-
in
64
-
{
65
-
watch-appview = {
66
-
type = "app";
67
-
program = ''${air-watcher "appview"}/bin/run'';
68
-
};
69
-
watch-knotserver = {
70
-
type = "app";
71
-
program = ''${air-watcher "knotserver"}/bin/run'';
72
-
};
56
+
apps = forAllSystems (system: let
57
+
pkgs = nixpkgsFor."${system}";
58
+
air-watcher = name:
59
+
pkgs.writeShellScriptBin "run"
60
+
''
61
+
${pkgs.air}/bin/air -c /dev/null -build.cmd "${pkgs.go}/bin/go build -o ./out/${name}.out ./cmd/${name}/main.go" -build.bin "./out/${name}.out"
62
+
'';
63
+
in {
64
+
watch-appview = {
65
+
type = "app";
66
+
program = ''${air-watcher "appview"}/bin/run'';
67
+
};
68
+
watch-knotserver = {
69
+
type = "app";
70
+
program = ''${air-watcher "knotserver"}/bin/run'';
71
+
};
73
72
});
74
73
};
75
74
}
+34
lexicons/policy.json
+34
lexicons/policy.json
···
1
+
{
2
+
"lexicon": 1,
3
+
"id": "sh.tangled.knot.policy",
4
+
"needsCbor": true,
5
+
"needsType": true,
6
+
"defs": {
7
+
"main": {
8
+
"type": "record",
9
+
"key": "tid",
10
+
"record": {
11
+
"type": "object",
12
+
"required": ["subject", "domain", "object", "action"],
13
+
"properties": {
14
+
"subject": {
15
+
"type": "string",
16
+
"description": "subject of the key"
17
+
},
18
+
"domain": {
19
+
"type": "string",
20
+
"description": "domain of the key"
21
+
},
22
+
"object": {
23
+
"type": "string",
24
+
"description": "object associated with the key"
25
+
},
26
+
"action": {
27
+
"type": "string",
28
+
"description": "action associated with the key"
29
+
}
30
+
}
31
+
}
32
+
}
33
+
}
34
+
}