commit 4a8d1810f6bc43cc290a58a7d5d994c19299f8f2 · edavis.dev/monarch

+24 -25
cmd/monarch/handlers.go
···

       4
       4
        
       	"bytes"

     

       5
       5
        
       	"context"

     

       6
       6
        
       	"encoding/json"

     

       7
       7
       -
       	"errors"

     

       8
       7
        
       	"fmt"

     

       9
       8
        
       	"io"

     

       10
       9
        
       

     
···

       42
       41
        
       }

     

       43
       42
        
       

     

       44
       43
        
       var validCollections = map[syntax.NSID]bool{

     

       45
       45
       -
       	syntax.NSID("app.bsky.actor.profile"):   true,

     

       46
       46
       -
       	syntax.NSID("app.bsky.feed.generator"):  true,

     

       47
       47
       -
       	syntax.NSID("app.bsky.labeler.service"): true,

     

       44
       44
       +
       	syntax.NSID("app.bsky.actor.profile"): true,

     

       45
       45
       +
       	// syntax.NSID("app.bsky.feed.generator"):  true,

     

       46
       46
       +
       	// syntax.NSID("app.bsky.labeler.service"): true,

     

       48
       47
        
       }

     

       49
       48
        
       

     

       50
       49
        
       type bskycbor interface {

     

       51
       50
        
       	UnmarshalCBOR(io.Reader) error

     

       52
       51
        
       }

     

       53
       52
        
       

     

       53
       53
       +
       func ActorProfile(data *[]byte) ([]byte, error) {

     

       54
       54
       +
       	var (

     

       55
       55
       +
       		model appbsky.ActorProfile

     

       56
       56
       +
       		body  []byte

     

       57
       57
       +
       		err   error

     

       58
       58
       +
       	)

     

       59
       59
       +
       	if err := model.UnmarshalCBOR(bytes.NewBuffer(*data)); err != nil {

     

       60
       60
       +
       		return body, fmt.Errorf("error cbor unmarshaling: %w", err)

     

       61
       61
       +
       	}

     

       62
       62
       +
       	body, err = json.Marshal(model)

     

       63
       63
       +
       	if err != nil {

     

       64
       64
       +
       		return body, fmt.Errorf("error json unmarshaling: %w", err)

     

       65
       65
       +
       	}

     

       66
       66
       +
       	return body, err

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       54
       69
        
       func (hs *HandlerService) HandleUpsert(ctx context.Context, repo string, rev string, path string, rec *[]byte, cid *cid.Cid, action Action) error {

     

       55
       70
        
       	uri, err := syntax.ParseATURI(fmt.Sprintf("at://%s/%s", repo, path))

     

       56
       71
        
       	if err != nil {

     

       57
       72
        
       		return fmt.Errorf("error parsing at-uri: %w", err)

     

       58
       73
        
       	}

     

       59
       74
        
       

     

       60
       60
       -
       	ok := validCollections[uri.Collection()]

     

       75
       75
       +
       	_, ok := validCollections[uri.Collection()]

     

       61
       76
        
       	if !ok {

     

       62
       77
        
       		return nil

     

       63
       78
        
       	}

     

       64
       79
        
       

     

       65
       65
       -
       	var out any

     

       80
       80
       +
       	var body []byte

     

       66
       81
        
       	switch uri.Collection() {

     

       67
       82
        
       	case syntax.NSID("app.bsky.actor.profile"):

     

       68
       68
       -
       		out = appbsky.ActorProfile{}

     

       69
       69
       -
       	case syntax.NSID("app.bsky.feed.generator"):

     

       70
       70
       -
       		out = appbsky.FeedGenerator{}

     

       71
       71
       -
       	case syntax.NSID("app.bsky.labeler.service"):

     

       72
       72
       -
       		out = appbsky.LabelerService{}

     

       73
       73
       -
       	}

     

       74
       74
       -
       

     

       75
       75
       -
       	model, ok := out.(bskycbor)

     

       76
       76
       -
       	if !ok {

     

       77
       77
       -
       		return errors.New("collection model cannot unmarshal CBOR")

     

       78
       78
       -
       	}

     

       79
       79
       -
       

     

       80
       80
       -
       	if err := model.UnmarshalCBOR(bytes.NewReader(*rec)); err != nil {

     

       81
       81
       -
       		return fmt.Errorf("error cbor unmarshaling: %w", err)

     

       82
       82
       -
       	}

     

       83
       83
       -
       

     

       84
       84
       -
       	body, err := json.Marshal(model)

     

       85
       85
       -
       	if err != nil {

     

       86
       86
       -
       		return fmt.Errorf("error json marshaling: %w", err)

     

       83
       83
       +
       		if body, err = ActorProfile(rec); err != nil {

     

       84
       84
       +
       			return fmt.Errorf("error parsing actor profile: %w", err)

     

       85
       85
       +
       		}

     

       87
       86
        
       	}

     

       88
       87
        
       

     

       89
       88
        
       	switch action {