data: rename some types, wire up cborgen

atproto/data/blob.go

···
 	Size     int64
 }
 
-type LegacyBlob struct {
+type LegacyBlobSchema struct {
 	Cid      string `json:"cid" cborgen:"cid"`
 	MimeType string `json:"mimeType" cborgen:"mimeType"`
 }
···
 
 func (b Blob) MarshalJSON() ([]byte, error) {
 	if b.Size < 0 {
-		lb := LegacyBlob{
+		lb := LegacyBlobSchema{
 			Cid:      b.Ref.String(),
 			MimeType: b.MimeType,
 		}
···
 }
 
 func (b *Blob) UnmarshalJSON(raw []byte) error {
-	typ, err := TypeExtract(raw)
+	typ, err := ExtractTypeJSON(raw)
 	if err != nil {
 		return fmt.Errorf("parsing blob type: %v", err)
 	}
···
 			return fmt.Errorf("parsing blob: negative size: %d", bs.Size)
 		}
 	} else {
-		var legacy LegacyBlob
+		var legacy LegacyBlobSchema
 		err := json.Unmarshal(raw, &legacy)
 		if err != nil {
 			return fmt.Errorf("parsing legacy blob: %v", err)
···
 		return err
 	}
 	if b.Size < 0 {
-		lb := LegacyBlob{
+		lb := LegacyBlobSchema{
 			Cid:      b.Ref.String(),
 			MimeType: b.MimeType,
 		}
···
 }
 
 func (lb *Blob) UnmarshalCBOR(r io.Reader) error {
-	typ, b, err := CborTypeExtractReader(r)
+	typ, b, err := ExtractTypeCBORReader(r)
 	if err != nil {
 		return fmt.Errorf("parsing $blob CBOR type: %w", err)
 	}
···
 			return fmt.Errorf("parsing $blob CBOR: negative size: %d", bs.Size)
 		}
 	} else {
-		legacy := LegacyBlob{}
+		legacy := LegacyBlobSchema{}
 		err := legacy.UnmarshalCBOR(bytes.NewReader(b))
 		if err != nil {
 			return fmt.Errorf("parsing legacy blob CBOR: %v", err)

atproto/data/cbor_gen.go

···
 var _ = math.E
 var _ = sort.Sort
 
-func (t *CborChecker) MarshalCBOR(w io.Writer) error {
+func (t *GenericRecord) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 	return nil
 }
 
-func (t *CborChecker) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = CborChecker{}
+func (t *GenericRecord) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GenericRecord{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("CborChecker: map struct too large (%d)", extra)
+		return fmt.Errorf("GenericRecord: map struct too large (%d)", extra)
 	}
 
 	var name string
···
 
 	return nil
 }
-func (t *LegacyBlob) MarshalCBOR(w io.Writer) error {
+func (t *LegacyBlobSchema) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 	return nil
 }
 
-func (t *LegacyBlob) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = LegacyBlob{}
+func (t *LegacyBlobSchema) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = LegacyBlobSchema{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("LegacyBlob: map struct too large (%d)", extra)
+		return fmt.Errorf("LegacyBlobSchema: map struct too large (%d)", extra)
 	}
 
 	var name string
···
 		return err
 	}
 
-	// t.Ref (util.LexLink) (struct)
+	// t.Ref (data.CIDLink) (struct)
 	if len("ref") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"ref\" was too long")
 	}
···
 		}
 
 		switch name {
-		// t.Ref (util.LexLink) (struct)
+		// t.Ref (data.CIDLink) (struct)
 		case "ref":
 
 			{

atproto/data/extract.go

···
 	"io"
 )
 
-type typeExtractor struct {
+// Helper type for extracting record $type from CBOR
+type GenericRecord struct {
 	Type string `json:"$type" cborgen:"$type"`
 }
 
-func TypeExtract(b []byte) (string, error) {
-	var te typeExtractor
-	if err := json.Unmarshal(b, &te); err != nil {
+// Parses the top-level $type field from generic atproto JSON data
+func ExtractTypeJSON(b []byte) (string, error) {
+	var gr GenericRecord
+	if err := json.Unmarshal(b, &gr); err != nil {
 		return "", err
 	}
 
-	return te.Type, nil
+	return gr.Type, nil
 }
 
-type CborChecker struct {
-	Type string `json:"$type" cborgen:"$type"`
-}
-
-func CborTypeExtract(b []byte) (string, error) {
-	var tcheck CborChecker
-	if err := tcheck.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
+// Parses the top-level $type field from generic atproto CBOR data
+func ExtractTypeCBOR(b []byte) (string, error) {
+	var gr GenericRecord
+	if err := gr.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
 		fmt.Printf("bad bytes: %x\n", b)
 		return "", err
 	}
 
-	return tcheck.Type, nil
+	return gr.Type, nil
 }
 
-func CborTypeExtractReader(r io.Reader) (string, []byte, error) {
+// Parses top-level $type field from generic atproto CBOR.
+//
+// Returns that string field, and additional bytes (TODO: the parsed bytes, or remaining bytes?)
+func ExtractTypeCBORReader(r io.Reader) (string, []byte, error) {
 	buf := new(bytes.Buffer)
 	tr := io.TeeReader(r, buf)
-	var tcheck CborChecker
-	if err := tcheck.UnmarshalCBOR(tr); err != nil {
+	var gr GenericRecord
+	if err := gr.UnmarshalCBOR(tr); err != nil {
 		return "", nil, err
 	}
 
-	return tcheck.Type, buf.Bytes(), nil
+	return gr.Type, buf.Bytes(), nil
 }

gen/main.go

···
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/bluesky-social/indigo/mst"
 	"github.com/bluesky-social/indigo/repo"
+	"github.com/bluesky-social/indigo/atproto/data"
+
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
···
 	}
 
 	if err := cbg.WriteMapEncodersToFile("events/cbor_gen.go", "events", events.EventHeader{}, events.ErrorFrame{}); err != nil {
+		panic(err)
+	}
+
+	if err := cbg.WriteMapEncodersToFile("atproto/data/cbor_gen.go", "data", data.GenericRecord{}, data.LegacyBlobSchema{}, data.BlobSchema{}); err != nil {
 		panic(err)
 	}
 }