From ec58866ed7c38511e2723919c3632950a0c321b9 Mon Sep 17 00:00:00 2001 From: Brian Olson Date: Mon, 19 Aug 2024 16:41:11 -0400 Subject: [PATCH] lexgen+cborgen for atproto branches reply-qp-moderation at 2d661f71e411e9e8de1ad1a15b5cceef08bcce8b divy/video at 92d6c6b1da73c6e7a243ae0f059a220e781fbd36 --- api/bsky/cbor_gen.go | 495 ++++++++++++++++++++++++++++++++++++- api/bsky/embedrecord.go | 17 ++ api/bsky/feeddefs.go | 9 +- api/bsky/feedpostgate.go | 92 +++++++ api/bsky/feedthreadgate.go | 2 + gen/main.go | 2 + 6 files changed, 612 insertions(+), 5 deletions(-) create mode 100644 api/bsky/feedpostgate.go diff --git a/api/bsky/cbor_gen.go b/api/bsky/cbor_gen.go index 2f130edf8..4287bcd51 100644 --- a/api/bsky/cbor_gen.go +++ b/api/bsky/cbor_gen.go @@ -5426,12 +5426,16 @@ func (t *FeedThreadgate) MarshalCBOR(w io.Writer) error { } cw := cbg.NewCborWriter(w) - fieldCount := 4 + fieldCount := 5 if t.Allow == nil { fieldCount-- } + if t.HiddenReplies == nil { + fieldCount-- + } + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { return err } @@ -5529,6 +5533,42 @@ func (t *FeedThreadgate) MarshalCBOR(w io.Writer) error { if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { return err } + + // t.HiddenReplies ([]string) (slice) + if t.HiddenReplies != nil { + + if len("hiddenReplies") > 1000000 { + return xerrors.Errorf("Value in field \"hiddenReplies\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("hiddenReplies"))); err != nil { + return err + } + if _, err := cw.WriteString(string("hiddenReplies")); err != nil { + return err + } + + if len(t.HiddenReplies) > 8192 { + return xerrors.Errorf("Slice value in field t.HiddenReplies was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.HiddenReplies))); err != nil { + return err + } + for _, v := range t.HiddenReplies { + if len(v) > 1000000 { + return xerrors.Errorf("Value in field v was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { + return err + } + if _, err := cw.WriteString(string(v)); err != nil { + return err + } + + } + } return nil } @@ -5652,6 +5692,46 @@ func (t *FeedThreadgate) UnmarshalCBOR(r io.Reader) (err error) { t.CreatedAt = string(sval) } + // t.HiddenReplies ([]string) (slice) + case "hiddenReplies": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.HiddenReplies: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.HiddenReplies = make([]string, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.HiddenReplies[i] = string(sval) + } + + } + } default: // Field doesn't exist on this type, so ignore it @@ -7357,3 +7437,416 @@ func (t *EmbedVideo_Caption) UnmarshalCBOR(r io.Reader) (err error) { return nil } +func (t *FeedPostgate) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + fieldCount := 5 + + if t.DetachedEmbeddingUris == nil { + fieldCount-- + } + + if t.EmbeddingRules == nil { + fieldCount-- + } + + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { + return err + } + + // t.Post (string) (string) + if len("post") > 1000000 { + return xerrors.Errorf("Value in field \"post\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("post"))); err != nil { + return err + } + if _, err := cw.WriteString(string("post")); err != nil { + return err + } + + if len(t.Post) > 1000000 { + return xerrors.Errorf("Value in field t.Post was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Post))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Post)); 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("app.bsky.feed.postgate"))); err != nil { + return err + } + if _, err := cw.WriteString(string("app.bsky.feed.postgate")); err != nil { + return err + } + + // t.CreatedAt (string) (string) + if len("createdAt") > 1000000 { + return xerrors.Errorf("Value in field \"createdAt\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { + return err + } + if _, err := cw.WriteString(string("createdAt")); err != nil { + return err + } + + if len(t.CreatedAt) > 1000000 { + return xerrors.Errorf("Value in field t.CreatedAt was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { + return err + } + + // t.EmbeddingRules ([]*bsky.FeedPostgate_EmbeddingRules_Elem) (slice) + if t.EmbeddingRules != nil { + + if len("embeddingRules") > 1000000 { + return xerrors.Errorf("Value in field \"embeddingRules\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("embeddingRules"))); err != nil { + return err + } + if _, err := cw.WriteString(string("embeddingRules")); err != nil { + return err + } + + if len(t.EmbeddingRules) > 8192 { + return xerrors.Errorf("Slice value in field t.EmbeddingRules was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.EmbeddingRules))); err != nil { + return err + } + for _, v := range t.EmbeddingRules { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + + } + } + + // t.DetachedEmbeddingUris ([]string) (slice) + if t.DetachedEmbeddingUris != nil { + + if len("detachedEmbeddingUris") > 1000000 { + return xerrors.Errorf("Value in field \"detachedEmbeddingUris\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("detachedEmbeddingUris"))); err != nil { + return err + } + if _, err := cw.WriteString(string("detachedEmbeddingUris")); err != nil { + return err + } + + if len(t.DetachedEmbeddingUris) > 8192 { + return xerrors.Errorf("Slice value in field t.DetachedEmbeddingUris was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.DetachedEmbeddingUris))); err != nil { + return err + } + for _, v := range t.DetachedEmbeddingUris { + if len(v) > 1000000 { + return xerrors.Errorf("Value in field v was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { + return err + } + if _, err := cw.WriteString(string(v)); err != nil { + return err + } + + } + } + return nil +} + +func (t *FeedPostgate) UnmarshalCBOR(r io.Reader) (err error) { + *t = FeedPostgate{} + + 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("FeedPostgate: map struct too large (%d)", extra) + } + + var name string + n := extra + + for i := uint64(0); i < n; i++ { + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + name = string(sval) + } + + switch name { + // t.Post (string) (string) + case "post": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Post = string(sval) + } + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + // t.CreatedAt (string) (string) + case "createdAt": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.CreatedAt = string(sval) + } + // t.EmbeddingRules ([]*bsky.FeedPostgate_EmbeddingRules_Elem) (slice) + case "embeddingRules": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.EmbeddingRules: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.EmbeddingRules = make([]*FeedPostgate_EmbeddingRules_Elem, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.EmbeddingRules[i] = new(FeedPostgate_EmbeddingRules_Elem) + if err := t.EmbeddingRules[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.EmbeddingRules[i] pointer: %w", err) + } + } + + } + + } + } + // t.DetachedEmbeddingUris ([]string) (slice) + case "detachedEmbeddingUris": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.DetachedEmbeddingUris: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DetachedEmbeddingUris = make([]string, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.DetachedEmbeddingUris[i] = string(sval) + } + + } + } + + default: + // Field doesn't exist on this type, so ignore it + cbg.ScanForLinks(r, func(cid.Cid) {}) + } + } + + return nil +} +func (t *FeedPostgate_DisableRule) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{161}); 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("app.bsky.feed.postgate#disableRule"))); err != nil { + return err + } + if _, err := cw.WriteString(string("app.bsky.feed.postgate#disableRule")); err != nil { + return err + } + return nil +} + +func (t *FeedPostgate_DisableRule) UnmarshalCBOR(r io.Reader) (err error) { + *t = FeedPostgate_DisableRule{} + + 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("FeedPostgate_DisableRule: map struct too large (%d)", extra) + } + + var name string + n := extra + + for i := uint64(0); i < n; i++ { + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + name = string(sval) + } + + switch name { + // t.LexiconTypeID (string) (string) + case "$type": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + cbg.ScanForLinks(r, func(cid.Cid) {}) + } + } + + return nil +} diff --git a/api/bsky/embedrecord.go b/api/bsky/embedrecord.go index 3103d8c72..dbeff69c1 100644 --- a/api/bsky/embedrecord.go +++ b/api/bsky/embedrecord.go @@ -39,6 +39,15 @@ type EmbedRecord_ViewBlocked struct { Uri string `json:"uri" cborgen:"uri"` } +// EmbedRecord_ViewDetached is a "viewDetached" in the app.bsky.embed.record schema. +// +// RECORDTYPE: EmbedRecord_ViewDetached +type EmbedRecord_ViewDetached struct { + LexiconTypeID string `json:"$type,const=app.bsky.embed.record#viewDetached" cborgen:"$type,const=app.bsky.embed.record#viewDetached"` + Detached bool `json:"detached" cborgen:"detached"` + Uri string `json:"uri" cborgen:"uri"` +} + // EmbedRecord_ViewNotFound is a "viewNotFound" in the app.bsky.embed.record schema. // // RECORDTYPE: EmbedRecord_ViewNotFound @@ -129,6 +138,7 @@ type EmbedRecord_View_Record struct { EmbedRecord_ViewRecord *EmbedRecord_ViewRecord EmbedRecord_ViewNotFound *EmbedRecord_ViewNotFound EmbedRecord_ViewBlocked *EmbedRecord_ViewBlocked + EmbedRecord_ViewDetached *EmbedRecord_ViewDetached FeedDefs_GeneratorView *FeedDefs_GeneratorView GraphDefs_ListView *GraphDefs_ListView LabelerDefs_LabelerView *LabelerDefs_LabelerView @@ -148,6 +158,10 @@ func (t *EmbedRecord_View_Record) MarshalJSON() ([]byte, error) { t.EmbedRecord_ViewBlocked.LexiconTypeID = "app.bsky.embed.record#viewBlocked" return json.Marshal(t.EmbedRecord_ViewBlocked) } + if t.EmbedRecord_ViewDetached != nil { + t.EmbedRecord_ViewDetached.LexiconTypeID = "app.bsky.embed.record#viewDetached" + return json.Marshal(t.EmbedRecord_ViewDetached) + } if t.FeedDefs_GeneratorView != nil { t.FeedDefs_GeneratorView.LexiconTypeID = "app.bsky.feed.defs#generatorView" return json.Marshal(t.FeedDefs_GeneratorView) @@ -182,6 +196,9 @@ func (t *EmbedRecord_View_Record) UnmarshalJSON(b []byte) error { case "app.bsky.embed.record#viewBlocked": t.EmbedRecord_ViewBlocked = new(EmbedRecord_ViewBlocked) return json.Unmarshal(b, t.EmbedRecord_ViewBlocked) + case "app.bsky.embed.record#viewDetached": + t.EmbedRecord_ViewDetached = new(EmbedRecord_ViewDetached) + return json.Unmarshal(b, t.EmbedRecord_ViewDetached) case "app.bsky.feed.defs#generatorView": t.FeedDefs_GeneratorView = new(FeedDefs_GeneratorView) return json.Unmarshal(b, t.FeedDefs_GeneratorView) diff --git a/api/bsky/feeddefs.go b/api/bsky/feeddefs.go index fa5622231..c2f0c1e91 100644 --- a/api/bsky/feeddefs.go +++ b/api/bsky/feeddefs.go @@ -438,8 +438,9 @@ type FeedDefs_ThreadgateView struct { // // Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests. type FeedDefs_ViewerState struct { - Like *string `json:"like,omitempty" cborgen:"like,omitempty"` - ReplyDisabled *bool `json:"replyDisabled,omitempty" cborgen:"replyDisabled,omitempty"` - Repost *string `json:"repost,omitempty" cborgen:"repost,omitempty"` - ThreadMuted *bool `json:"threadMuted,omitempty" cborgen:"threadMuted,omitempty"` + EmbeddingDisabled *bool `json:"embeddingDisabled,omitempty" cborgen:"embeddingDisabled,omitempty"` + Like *string `json:"like,omitempty" cborgen:"like,omitempty"` + ReplyDisabled *bool `json:"replyDisabled,omitempty" cborgen:"replyDisabled,omitempty"` + Repost *string `json:"repost,omitempty" cborgen:"repost,omitempty"` + ThreadMuted *bool `json:"threadMuted,omitempty" cborgen:"threadMuted,omitempty"` } diff --git a/api/bsky/feedpostgate.go b/api/bsky/feedpostgate.go new file mode 100644 index 000000000..518bf5766 --- /dev/null +++ b/api/bsky/feedpostgate.go @@ -0,0 +1,92 @@ +// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. + +package bsky + +// schema: app.bsky.feed.postgate + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + + "github.com/bluesky-social/indigo/lex/util" + cbg "github.com/whyrusleeping/cbor-gen" +) + +func init() { + util.RegisterType("app.bsky.feed.postgate", &FeedPostgate{}) +} // +// RECORDTYPE: FeedPostgate +type FeedPostgate struct { + LexiconTypeID string `json:"$type,const=app.bsky.feed.postgate" cborgen:"$type,const=app.bsky.feed.postgate"` + CreatedAt string `json:"createdAt" cborgen:"createdAt"` + // detachedEmbeddingUris: List of AT-URIs embedding this post that the author has detached from. + DetachedEmbeddingUris []string `json:"detachedEmbeddingUris,omitempty" cborgen:"detachedEmbeddingUris,omitempty"` + EmbeddingRules []*FeedPostgate_EmbeddingRules_Elem `json:"embeddingRules,omitempty" cborgen:"embeddingRules,omitempty"` + // post: Reference (AT-URI) to the post record. + Post string `json:"post" cborgen:"post"` +} + +// FeedPostgate_DisableRule is a "disableRule" in the app.bsky.feed.postgate schema. +// +// Disables embedding of this post. +// +// RECORDTYPE: FeedPostgate_DisableRule +type FeedPostgate_DisableRule struct { + LexiconTypeID string `json:"$type,const=app.bsky.feed.postgate#disableRule" cborgen:"$type,const=app.bsky.feed.postgate#disableRule"` +} + +type FeedPostgate_EmbeddingRules_Elem struct { + FeedPostgate_DisableRule *FeedPostgate_DisableRule +} + +func (t *FeedPostgate_EmbeddingRules_Elem) MarshalJSON() ([]byte, error) { + if t.FeedPostgate_DisableRule != nil { + t.FeedPostgate_DisableRule.LexiconTypeID = "app.bsky.feed.postgate#disableRule" + return json.Marshal(t.FeedPostgate_DisableRule) + } + return nil, fmt.Errorf("cannot marshal empty enum") +} +func (t *FeedPostgate_EmbeddingRules_Elem) UnmarshalJSON(b []byte) error { + typ, err := util.TypeExtract(b) + if err != nil { + return err + } + + switch typ { + case "app.bsky.feed.postgate#disableRule": + t.FeedPostgate_DisableRule = new(FeedPostgate_DisableRule) + return json.Unmarshal(b, t.FeedPostgate_DisableRule) + + default: + return nil + } +} + +func (t *FeedPostgate_EmbeddingRules_Elem) MarshalCBOR(w io.Writer) error { + + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if t.FeedPostgate_DisableRule != nil { + return t.FeedPostgate_DisableRule.MarshalCBOR(w) + } + return fmt.Errorf("cannot cbor marshal empty enum") +} +func (t *FeedPostgate_EmbeddingRules_Elem) UnmarshalCBOR(r io.Reader) error { + typ, b, err := util.CborTypeExtractReader(r) + if err != nil { + return err + } + + switch typ { + case "app.bsky.feed.postgate#disableRule": + t.FeedPostgate_DisableRule = new(FeedPostgate_DisableRule) + return t.FeedPostgate_DisableRule.UnmarshalCBOR(bytes.NewReader(b)) + + default: + return nil + } +} diff --git a/api/bsky/feedthreadgate.go b/api/bsky/feedthreadgate.go index 11152a1b1..72c04457e 100644 --- a/api/bsky/feedthreadgate.go +++ b/api/bsky/feedthreadgate.go @@ -22,6 +22,8 @@ type FeedThreadgate struct { LexiconTypeID string `json:"$type,const=app.bsky.feed.threadgate" cborgen:"$type,const=app.bsky.feed.threadgate"` Allow []*FeedThreadgate_Allow_Elem `json:"allow,omitempty" cborgen:"allow,omitempty"` CreatedAt string `json:"createdAt" cborgen:"createdAt"` + // hiddenReplies: List of hidden reply URIs. + HiddenReplies []string `json:"hiddenReplies,omitempty" cborgen:"hiddenReplies,omitempty"` // post: Reference (AT-URI) to the post record. Post string `json:"post" cborgen:"post"` } diff --git a/gen/main.go b/gen/main.go index 21f84abb1..2fe529103 100644 --- a/gen/main.go +++ b/gen/main.go @@ -68,6 +68,8 @@ func main() { bsky.LabelerService{}, bsky.LabelerDefs_LabelerPolicies{}, bsky.EmbedVideo{}, bsky.EmbedVideo_Caption{}, + bsky.FeedPostgate{}, + bsky.FeedPostgate_DisableRule{}, /*bsky.EmbedImages_View{}, bsky.EmbedRecord_View{}, bsky.EmbedRecordWithMedia_View{}, bsky.EmbedExternal_View{}, bsky.EmbedImages_ViewImage{},