+232

api/tangled/cbor_gen.go

··· 216 216 217 217 return nil 218 218 } 219 219 + func (t *KnotPolicy) MarshalCBOR(w io.Writer) error { 220 220 + if t == nil { 221 221 + _, err := w.Write(cbg.CborNull) 222 222 + return err 223 223 + } 224 224 + 225 225 + cw := cbg.NewCborWriter(w) 226 226 + 227 227 + if _, err := cw.Write([]byte{165}); err != nil { 228 228 + return err 229 229 + } 230 230 + 231 231 + // t.LexiconTypeID (string) (string) 232 232 + if len("$type") > 1000000 { 233 233 + return xerrors.Errorf("Value in field \"$type\" was too long") 234 234 + } 235 235 + 236 236 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 237 237 + return err 238 238 + } 239 239 + if _, err := cw.WriteString(string("$type")); err != nil { 240 240 + return err 241 241 + } 242 242 + 243 243 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.policy"))); err != nil { 244 244 + return err 245 245 + } 246 246 + if _, err := cw.WriteString(string("sh.tangled.knot.policy")); err != nil { 247 247 + return err 248 248 + } 249 249 + 250 250 + // t.Action (string) (string) 251 251 + if len("action") > 1000000 { 252 252 + return xerrors.Errorf("Value in field \"action\" was too long") 253 253 + } 254 254 + 255 255 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil { 256 256 + return err 257 257 + } 258 258 + if _, err := cw.WriteString(string("action")); err != nil { 259 259 + return err 260 260 + } 261 261 + 262 262 + if len(t.Action) > 1000000 { 263 263 + return xerrors.Errorf("Value in field t.Action was too long") 264 264 + } 265 265 + 266 266 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil { 267 267 + return err 268 268 + } 269 269 + if _, err := cw.WriteString(string(t.Action)); err != nil { 270 270 + return err 271 271 + } 272 272 + 273 273 + // t.Domain (string) (string) 274 274 + if len("domain") > 1000000 { 275 275 + return xerrors.Errorf("Value in field \"domain\" was too long") 276 276 + } 277 277 + 278 278 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil { 279 279 + return err 280 280 + } 281 281 + if _, err := cw.WriteString(string("domain")); err != nil { 282 282 + return err 283 283 + } 284 284 + 285 285 + if len(t.Domain) > 1000000 { 286 286 + return xerrors.Errorf("Value in field t.Domain was too long") 287 287 + } 288 288 + 289 289 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil { 290 290 + return err 291 291 + } 292 292 + if _, err := cw.WriteString(string(t.Domain)); err != nil { 293 293 + return err 294 294 + } 295 295 + 296 296 + // t.Object (string) (string) 297 297 + if len("object") > 1000000 { 298 298 + return xerrors.Errorf("Value in field \"object\" was too long") 299 299 + } 300 300 + 301 301 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("object"))); err != nil { 302 302 + return err 303 303 + } 304 304 + if _, err := cw.WriteString(string("object")); err != nil { 305 305 + return err 306 306 + } 307 307 + 308 308 + if len(t.Object) > 1000000 { 309 309 + return xerrors.Errorf("Value in field t.Object was too long") 310 310 + } 311 311 + 312 312 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Object))); err != nil { 313 313 + return err 314 314 + } 315 315 + if _, err := cw.WriteString(string(t.Object)); err != nil { 316 316 + return err 317 317 + } 318 318 + 319 319 + // t.Subject (string) (string) 320 320 + if len("subject") > 1000000 { 321 321 + return xerrors.Errorf("Value in field \"subject\" was too long") 322 322 + } 323 323 + 324 324 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 325 325 + return err 326 326 + } 327 327 + if _, err := cw.WriteString(string("subject")); err != nil { 328 328 + return err 329 329 + } 330 330 + 331 331 + if len(t.Subject) > 1000000 { 332 332 + return xerrors.Errorf("Value in field t.Subject was too long") 333 333 + } 334 334 + 335 335 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 336 336 + return err 337 337 + } 338 338 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 339 339 + return err 340 340 + } 341 341 + return nil 342 342 + } 343 343 + 344 344 + func (t *KnotPolicy) UnmarshalCBOR(r io.Reader) (err error) { 345 345 + *t = KnotPolicy{} 346 346 + 347 347 + cr := cbg.NewCborReader(r) 348 348 + 349 349 + maj, extra, err := cr.ReadHeader() 350 350 + if err != nil { 351 351 + return err 352 352 + } 353 353 + defer func() { 354 354 + if err == io.EOF { 355 355 + err = io.ErrUnexpectedEOF 356 356 + } 357 357 + }() 358 358 + 359 359 + if maj != cbg.MajMap { 360 360 + return fmt.Errorf("cbor input should be of type map") 361 361 + } 362 362 + 363 363 + if extra > cbg.MaxLength { 364 364 + return fmt.Errorf("KnotPolicy: map struct too large (%d)", extra) 365 365 + } 366 366 + 367 367 + n := extra 368 368 + 369 369 + nameBuf := make([]byte, 7) 370 370 + for i := uint64(0); i < n; i++ { 371 371 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 372 372 + if err != nil { 373 373 + return err 374 374 + } 375 375 + 376 376 + if !ok { 377 377 + // Field doesn't exist on this type, so ignore it 378 378 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 379 379 + return err 380 380 + } 381 381 + continue 382 382 + } 383 383 + 384 384 + switch string(nameBuf[:nameLen]) { 385 385 + // t.LexiconTypeID (string) (string) 386 386 + case "$type": 387 387 + 388 388 + { 389 389 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 390 390 + if err != nil { 391 391 + return err 392 392 + } 393 393 + 394 394 + t.LexiconTypeID = string(sval) 395 395 + } 396 396 + // t.Action (string) (string) 397 397 + case "action": 398 398 + 399 399 + { 400 400 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 401 401 + if err != nil { 402 402 + return err 403 403 + } 404 404 + 405 405 + t.Action = string(sval) 406 406 + } 407 407 + // t.Domain (string) (string) 408 408 + case "domain": 409 409 + 410 410 + { 411 411 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 412 412 + if err != nil { 413 413 + return err 414 414 + } 415 415 + 416 416 + t.Domain = string(sval) 417 417 + } 418 418 + // t.Object (string) (string) 419 419 + case "object": 420 420 + 421 421 + { 422 422 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 423 423 + if err != nil { 424 424 + return err 425 425 + } 426 426 + 427 427 + t.Object = string(sval) 428 428 + } 429 429 + // t.Subject (string) (string) 430 430 + case "subject": 431 431 + 432 432 + { 433 433 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 434 434 + if err != nil { 435 435 + return err 436 436 + } 437 437 + 438 438 + t.Subject = string(sval) 439 439 + } 440 440 + 441 441 + default: 442 442 + // Field doesn't exist on this type, so ignore it 443 443 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 444 444 + return err 445 445 + } 446 446 + } 447 447 + } 448 448 + 449 449 + return nil 450 450 + }

+29

api/tangled/knotpolicy.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.knot.policy 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + KnotPolicyNSID = "sh.tangled.knot.policy" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.knot.policy", &KnotPolicy{}) 17 17 + } // 18 18 + // RECORDTYPE: KnotPolicy 19 19 + type KnotPolicy struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.knot.policy" cborgen:"$type,const=sh.tangled.knot.policy"` 21 21 + // action: action associated with the key 22 22 + Action string `json:"action" cborgen:"action"` 23 23 + // domain: domain of the key 24 24 + Domain string `json:"domain" cborgen:"domain"` 25 25 + // object: object associated with the key 26 26 + Object string `json:"object" cborgen:"object"` 27 27 + // subject: subject of the key 28 28 + Subject string `json:"subject" cborgen:"subject"` 29 29 + }

+1

cmd/gen.go

··· 15 15 "api/tangled/cbor_gen.go", 16 16 "tangled", 17 17 shtangled.PublicKey{}, 18 18 + shtangled.KnotPolicy{}, 18 19 ); err != nil { 19 20 panic(err) 20 21 }

+6 -6

flake.lock

··· 3 3 "indigo": { 4 4 "flake": false, 5 5 "locked": { 6 6 - "lastModified": 1738055559, 7 7 - "narHash": "sha256-wsey8gs825Tm9Q3zITqg4B6TmHCDuV9vyQlXEnD/7/I=", 6 6 + "lastModified": 1738491661, 7 7 + "narHash": "sha256-+njDigkvjH4XmXZMog5Mp0K4x9mamHX6gSGJCZB9mE4=", 8 8 "owner": "oppiliappan", 9 9 "repo": "indigo", 10 10 - "rev": "9b475b7509c21b98b6ccd97c6d3f2e8d8ea3eae0", 10 10 + "rev": "feb802f02a462ac0a6392ffc3e40b0529f0cdf71", 11 11 "type": "github" 12 12 }, 13 13 "original": { ··· 18 18 }, 19 19 "nixpkgs": { 20 20 "locked": { 21 21 - "lastModified": 1737753923, 22 22 - "narHash": "sha256-O30NErrRU1AMlHoIbsKWs57Lvi8IgGvs+2ZtkTtq7b8=", 21 21 + "lastModified": 1738589849, 22 22 + "narHash": "sha256-YbBrqtYjo7HB+gA2WKN2jWxj0H2e5dBwYrbWeIyirAc=", 23 23 "owner": "nixos", 24 24 "repo": "nixpkgs", 25 25 - "rev": "a019ad96aa3710cd05710839f153f58c0325d486", 25 25 + "rev": "e4a4b2cf12d2c4c15dd6387c74421999095c49ad", 26 26 "type": "github" 27 27 }, 28 28 "original": {

+17 -18

flake.nix

··· 29 29 version = "0.1.0"; 30 30 src = indigo; 31 31 subPackage = ["cmd/lexgen"]; 32 32 - vendorHash = null; 32 32 + vendorHash = "sha256-pGc29fgJFq8LP7n/pY1cv6ExZl88PAeFqIbFEhB3xXs="; 33 33 doCheck = false; 34 34 }; 35 35 }; ··· 53 53 ]; 54 54 }; 55 55 }); 56 56 - apps = forAllSystems (system: 57 57 - let 58 58 - pkgs = nixpkgsFor."${system}"; 59 59 - air-watcher = name: pkgs.writeShellScriptBin "run" 60 60 - '' 61 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 62 - ''; 63 63 - in 64 64 - { 65 65 - watch-appview = { 66 66 - type = "app"; 67 67 - program = ''${air-watcher "appview"}/bin/run''; 68 68 - }; 69 69 - watch-knotserver = { 70 70 - type = "app"; 71 71 - program = ''${air-watcher "knotserver"}/bin/run''; 72 72 - }; 56 56 + apps = forAllSystems (system: let 57 57 + pkgs = nixpkgsFor."${system}"; 58 58 + air-watcher = name: 59 59 + pkgs.writeShellScriptBin "run" 60 60 + '' 61 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 62 + ''; 63 63 + in { 64 64 + watch-appview = { 65 65 + type = "app"; 66 66 + program = ''${air-watcher "appview"}/bin/run''; 67 67 + }; 68 68 + watch-knotserver = { 69 69 + type = "app"; 70 70 + program = ''${air-watcher "knotserver"}/bin/run''; 71 71 + }; 73 72 }); 74 73 }; 75 74 }

+34

lexicons/policy.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.knot.policy", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "record": { 11 11 + "type": "object", 12 12 + "required": ["subject", "domain", "object", "action"], 13 13 + "properties": { 14 14 + "subject": { 15 15 + "type": "string", 16 16 + "description": "subject of the key" 17 17 + }, 18 18 + "domain": { 19 19 + "type": "string", 20 20 + "description": "domain of the key" 21 21 + }, 22 22 + "object": { 23 23 + "type": "string", 24 24 + "description": "object associated with the key" 25 25 + }, 26 26 + "action": { 27 27 + "type": "string", 28 28 + "description": "action associated with the key" 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + }