lexicon: add sh.tangled.knot.policy (#3)

* lexicon: add sh.tangled.knot.policy

* i ran lexgen

* i ran nix fmt

---------

Co-authored-by: Akshay <[e-mail]>

api/tangled/cbor_gen.go

···
 
 	return nil
 }
+func (t *KnotPolicy) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{165}); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.policy"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.knot.policy")); err != nil {
+		return err
+	}
+
+	// t.Action (string) (string)
+	if len("action") > 1000000 {
+		return xerrors.Errorf("Value in field \"action\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("action"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("action")); err != nil {
+		return err
+	}
+
+	if len(t.Action) > 1000000 {
+		return xerrors.Errorf("Value in field t.Action was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Action))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Action)); err != nil {
+		return err
+	}
+
+	// t.Domain (string) (string)
+	if len("domain") > 1000000 {
+		return xerrors.Errorf("Value in field \"domain\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("domain")); err != nil {
+		return err
+	}
+
+	if len(t.Domain) > 1000000 {
+		return xerrors.Errorf("Value in field t.Domain was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Domain)); err != nil {
+		return err
+	}
+
+	// t.Object (string) (string)
+	if len("object") > 1000000 {
+		return xerrors.Errorf("Value in field \"object\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("object"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("object")); err != nil {
+		return err
+	}
+
+	if len(t.Object) > 1000000 {
+		return xerrors.Errorf("Value in field t.Object was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Object))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Object)); err != nil {
+		return err
+	}
+
+	// t.Subject (string) (string)
+	if len("subject") > 1000000 {
+		return xerrors.Errorf("Value in field \"subject\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("subject")); err != nil {
+		return err
+	}
+
+	if len(t.Subject) > 1000000 {
+		return xerrors.Errorf("Value in field t.Subject was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Subject)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *KnotPolicy) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = KnotPolicy{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("KnotPolicy: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 7)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Action (string) (string)
+		case "action":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Action = string(sval)
+			}
+			// t.Domain (string) (string)
+		case "domain":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Domain = string(sval)
+			}
+			// t.Object (string) (string)
+		case "object":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Object = string(sval)
+			}
+			// t.Subject (string) (string)
+		case "subject":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Subject = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

api/tangled/knotpolicy.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package tangled
+
+// schema: sh.tangled.knot.policy
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+const (
+	KnotPolicyNSID = "sh.tangled.knot.policy"
+)
+
+func init() {
+	util.RegisterType("sh.tangled.knot.policy", &KnotPolicy{})
+} //
+// RECORDTYPE: KnotPolicy
+type KnotPolicy struct {
+	LexiconTypeID string `json:"$type,const=sh.tangled.knot.policy" cborgen:"$type,const=sh.tangled.knot.policy"`
+	// action: action associated with the key
+	Action string `json:"action" cborgen:"action"`
+	// domain: domain of the key
+	Domain string `json:"domain" cborgen:"domain"`
+	// object: object associated with the key
+	Object string `json:"object" cborgen:"object"`
+	// subject: subject of the key
+	Subject string `json:"subject" cborgen:"subject"`
+}

cmd/gen.go

···
 		"api/tangled/cbor_gen.go",
 		"tangled",
 		shtangled.PublicKey{},
+		shtangled.KnotPolicy{},
 	); err != nil {
 		panic(err)
 	}

flake.lock

···
     "indigo": {
       "flake": false,
       "locked": {
-        "lastModified": 1738055559,
-        "narHash": "sha256-wsey8gs825Tm9Q3zITqg4B6TmHCDuV9vyQlXEnD/7/I=",
+        "lastModified": 1738491661,
+        "narHash": "sha256-+njDigkvjH4XmXZMog5Mp0K4x9mamHX6gSGJCZB9mE4=",
         "owner": "oppiliappan",
         "repo": "indigo",
-        "rev": "9b475b7509c21b98b6ccd97c6d3f2e8d8ea3eae0",
+        "rev": "feb802f02a462ac0a6392ffc3e40b0529f0cdf71",
         "type": "github"
       },
       "original": {
···
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1737753923,
-        "narHash": "sha256-O30NErrRU1AMlHoIbsKWs57Lvi8IgGvs+2ZtkTtq7b8=",
+        "lastModified": 1738589849,
+        "narHash": "sha256-YbBrqtYjo7HB+gA2WKN2jWxj0H2e5dBwYrbWeIyirAc=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "a019ad96aa3710cd05710839f153f58c0325d486",
+        "rev": "e4a4b2cf12d2c4c15dd6387c74421999095c49ad",
         "type": "github"
       },
       "original": {

flake.nix

···
           version = "0.1.0";
           src = indigo;
           subPackage = ["cmd/lexgen"];
-          vendorHash = null;
+          vendorHash = "sha256-pGc29fgJFq8LP7n/pY1cv6ExZl88PAeFqIbFEhB3xXs=";
           doCheck = false;
         };
     };
···
         ];
       };
     });
-    apps = forAllSystems (system:
-        let
-            pkgs = nixpkgsFor."${system}";
-            air-watcher = name: pkgs.writeShellScriptBin "run"
-            ''
-                ${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"
-            '';
-        in
-    {
-        watch-appview = {
-            type = "app";
-            program = ''${air-watcher "appview"}/bin/run'';
-        };
-        watch-knotserver = {
-            type = "app";
-            program = ''${air-watcher "knotserver"}/bin/run'';
-        };
+    apps = forAllSystems (system: let
+      pkgs = nixpkgsFor."${system}";
+      air-watcher = name:
+        pkgs.writeShellScriptBin "run"
+        ''
+          ${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"
+        '';
+    in {
+      watch-appview = {
+        type = "app";
+        program = ''${air-watcher "appview"}/bin/run'';
+      };
+      watch-knotserver = {
+        type = "app";
+        program = ''${air-watcher "knotserver"}/bin/run'';
+      };
     });
   };
 }

lexicons/policy.json

···
+{
+    "lexicon": 1,
+    "id": "sh.tangled.knot.policy",
+    "needsCbor": true,
+    "needsType": true,
+    "defs": {
+        "main": {
+            "type": "record",
+            "key": "tid",
+            "record": {
+                "type": "object",
+                "required": ["subject", "domain", "object", "action"],
+                "properties": {
+                    "subject": {
+                        "type": "string",
+                        "description": "subject of the key"
+                    },
+                    "domain": {
+                        "type": "string",
+                        "description": "domain of the key"
+                    },
+                    "object": {
+                        "type": "string",
+                        "description": "object associated with the key"
+                    },
+                    "action": {
+                        "type": "string",
+                        "description": "action associated with the key"
+                    }
+                }
+            }
+        }
+    }
+}