oppi.li
1package bgs
2
3import (
4 "fmt"
5 "io"
6 "net/http"
7 "strconv"
8
9 comatprototypes "github.com/bluesky-social/indigo/api/atproto"
10 "github.com/bluesky-social/indigo/atproto/syntax"
11 "github.com/ipfs/go-cid"
12 "github.com/labstack/echo/v4"
13 "go.opentelemetry.io/otel"
14)
15
16type XRPCError struct {
17 Message string `json:"message"`
18}
19
20func (s *BGS) HandleComAtprotoSyncGetBlocks(c echo.Context) error {
21 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetBlocks")
22 defer span.End()
23
24 cids := c.QueryParams()["cids"]
25 did := c.QueryParam("did")
26 _, err := syntax.ParseDID(did)
27 if err != nil {
28 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid did: %s", did)})
29 }
30
31 for _, cd := range cids {
32 _, err = cid.Parse(cd)
33 if err != nil {
34 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid cid: %s", cd)})
35 }
36 }
37
38 var out io.Reader
39 var handleErr error
40 // func (s *BGS) handleComAtprotoSyncGetBlocks(ctx context.Context,cids []string,did string) (io.Reader, error)
41 out, handleErr = s.handleComAtprotoSyncGetBlocks(ctx, cids, did)
42 if handleErr != nil {
43 return handleErr
44 }
45 return c.Stream(200, "application/vnd.ipld.car", out)
46}
47
48func (s *BGS) HandleComAtprotoSyncGetLatestCommit(c echo.Context) error {
49 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetLatestCommit")
50 defer span.End()
51 did := c.QueryParam("did")
52
53 _, err := syntax.ParseDID(did)
54 if err != nil {
55 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid did: %s", did)})
56 }
57
58 var out *comatprototypes.SyncGetLatestCommit_Output
59 var handleErr error
60 // func (s *BGS) handleComAtprotoSyncGetLatestCommit(ctx context.Context,did string) (*comatprototypes.SyncGetLatestCommit_Output, error)
61 out, handleErr = s.handleComAtprotoSyncGetLatestCommit(ctx, did)
62 if handleErr != nil {
63 return handleErr
64 }
65 return c.JSON(200, out)
66}
67
68func (s *BGS) HandleComAtprotoSyncGetRecord(c echo.Context) error {
69 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRecord")
70 defer span.End()
71 collection := c.QueryParam("collection")
72 did := c.QueryParam("did")
73 rkey := c.QueryParam("rkey")
74
75 _, err := syntax.ParseRecordKey(rkey)
76 if err != nil {
77 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid rkey: %s", rkey)})
78 }
79
80 _, err = syntax.ParseNSID(collection)
81 if err != nil {
82 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid collection: %s", collection)})
83 }
84
85 _, err = syntax.ParseDID(did)
86 if err != nil {
87 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid did: %s", did)})
88 }
89
90 var out io.Reader
91 var handleErr error
92 // func (s *BGS) handleComAtprotoSyncGetRecord(ctx context.Context,collection string,commit string,did string,rkey string) (io.Reader, error)
93 out, handleErr = s.handleComAtprotoSyncGetRecord(ctx, collection, did, rkey)
94 if handleErr != nil {
95 return handleErr
96 }
97 return c.Stream(200, "application/vnd.ipld.car", out)
98}
99
100func (s *BGS) HandleComAtprotoSyncGetRepo(c echo.Context) error {
101 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRepo")
102 defer span.End()
103 did := c.QueryParam("did")
104 since := c.QueryParam("since")
105
106 _, err := syntax.ParseDID(did)
107 if err != nil {
108 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid did: %s", did)})
109 }
110
111 var out io.Reader
112 var handleErr error
113 // func (s *BGS) handleComAtprotoSyncGetRepo(ctx context.Context,did string,since string) (io.Reader, error)
114 out, handleErr = s.handleComAtprotoSyncGetRepo(ctx, did, since)
115 if handleErr != nil {
116 return handleErr
117 }
118 return c.Stream(200, "application/vnd.ipld.car", out)
119}
120
121func (s *BGS) HandleComAtprotoSyncListRepos(c echo.Context) error {
122 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncListRepos")
123 defer span.End()
124
125 cursorQuery := c.QueryParam("cursor")
126 limitQuery := c.QueryParam("limit")
127
128 var err error
129
130 limit := 500
131 if limitQuery != "" {
132 limit, err = strconv.Atoi(limitQuery)
133 if err != nil || limit < 1 || limit > 1000 {
134 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid limit: %s", limitQuery)})
135 }
136 }
137
138 cursor := int64(0)
139 if cursorQuery != "" {
140 cursor, err = strconv.ParseInt(cursorQuery, 10, 64)
141 if err != nil || cursor < 0 {
142 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid cursor: %s", cursorQuery)})
143 }
144 }
145
146 out, handleErr := s.handleComAtprotoSyncListRepos(ctx, cursor, limit)
147 if handleErr != nil {
148 return handleErr
149 }
150 return c.JSON(200, out)
151}
152
153func (s *BGS) HandleComAtprotoSyncNotifyOfUpdate(c echo.Context) error {
154 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncNotifyOfUpdate")
155 defer span.End()
156
157 var body comatprototypes.SyncNotifyOfUpdate_Input
158 if err := c.Bind(&body); err != nil {
159 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid body: %s", err)})
160 }
161 var handleErr error
162 // func (s *BGS) handleComAtprotoSyncNotifyOfUpdate(ctx context.Context,body *comatprototypes.SyncNotifyOfUpdate_Input) error
163 handleErr = s.handleComAtprotoSyncNotifyOfUpdate(ctx, &body)
164 if handleErr != nil {
165 return handleErr
166 }
167 return nil
168}
169
170func (s *BGS) HandleComAtprotoSyncRequestCrawl(c echo.Context) error {
171 ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncRequestCrawl")
172 defer span.End()
173
174 var body comatprototypes.SyncRequestCrawl_Input
175 if err := c.Bind(&body); err != nil {
176 return c.JSON(http.StatusBadRequest, XRPCError{Message: fmt.Sprintf("invalid body: %s", err)})
177 }
178 var handleErr error
179 // func (s *BGS) handleComAtprotoSyncRequestCrawl(ctx context.Context,body *comatprototypes.SyncRequestCrawl_Input) error
180 handleErr = s.handleComAtprotoSyncRequestCrawl(ctx, &body)
181 if handleErr != nil {
182 return handleErr
183 }
184 return nil
185}