0
0
package pdsclient
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/recordcid"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/b64"
"github.com/bluesky-social/indigo/atproto/atdata"
"github.com/bluesky-social/indigo/atproto/syntax"
"github.com/ipfs/go-cid"
)
func parseBaseURL(raw string, schemes ...string) (*url.URL, error) {
raw = strings.TrimSpace(raw)
if raw == "" {
return nil, fmt.Errorf("%w: base URL is required", ErrInvalidConfig)
}
if !strings.Contains(raw, "://") {
return nil, fmt.Errorf("%w: base URL needs a scheme", ErrInvalidConfig)
}
parsed, err := url.Parse(raw)
if err != nil {
return nil, fmt.Errorf("%w: parsing base URL: %v", ErrInvalidConfig, err)
}
if parsed.Host == "" {
return nil, fmt.Errorf("%w: base URL has no host", ErrInvalidConfig)
}
if parsed.User != nil {
return nil, fmt.Errorf("%w: base URL must not carry user info", ErrInvalidConfig)
}
allowed := false
for _, scheme := range schemes {
if strings.EqualFold(parsed.Scheme, scheme) {
allowed = true
break
}
}
if !allowed {
return nil, fmt.Errorf("%w: unsupported base URL scheme", ErrInvalidConfig)
}
parsed.RawQuery = ""
parsed.Fragment = ""
return parsed, nil
}
func cloneNoRedirect(client *http.Client) *http.Client {
if client == nil {
return nil
}
out := *client
out.CheckRedirect = func(*http.Request, []*http.Request) error {
return http.ErrUseLastResponse
}
return &out
}
type basePDS struct {
client *xrpcClient
dial func(ctx context.Context, cursor *int64) (RepoEventStream, error)
}
func (b *basePDS) Describe(ctx context.Context) (Info, error) {
var out struct {
DID string `json:"did"`
AvailableUserDomains []string `json:"availableUserDomains"`
Version string `json:"version"`
}
if err := b.client.getJSON(ctx, "com.atproto.server.describeServer", nil, nil, &out); err != nil {
return Info{}, err
}
did, err := syntax.ParseDID(strings.TrimSpace(out.DID))
if err != nil {
return Info{}, fmt.Errorf("%w: describeServer returned an invalid did", ErrUnexpectedResponse)
}
if b.client.expectedDID != "" && did != b.client.expectedDID {
return Info{}, fmt.Errorf("%w: expected %s, got %s", ErrIdentityMismatch, b.client.expectedDID, did)
}
return Info{
DID: did,
AvailableUserDomains: append([]string(nil), out.AvailableUserDomains...),
Version: out.Version,
}, nil
}
func validatePath(path RepoPath, requireRkey bool) error {
if strings.TrimSpace(path.Repo.String()) == "" {
return fmt.Errorf("%w: repo is required", ErrInvalidRequest)
}
if strings.TrimSpace(path.Collection.String()) == "" {
return fmt.Errorf("%w: collection is required", ErrInvalidRequest)
}
if requireRkey && strings.TrimSpace(path.Rkey.String()) == "" {
return fmt.Errorf("%w: rkey is required", ErrInvalidRequest)
}
return nil
}
func validateRecord(record []byte) error {
if len(bytes.TrimSpace(record)) == 0 {
return fmt.Errorf("%w: record is required", ErrInvalidRequest)
}
normalized, err := b64.NormalizeJSONBytes(record)
if err != nil {
return fmt.Errorf("%w: invalid record: %v", ErrInvalidRequest, err)
}
parsed, err := atdata.UnmarshalJSON(normalized)
if err != nil {
return fmt.Errorf("%w: invalid record: %v", ErrInvalidRequest, err)
}
if parsed == nil {
return fmt.Errorf("%w: record must be a JSON object", ErrInvalidRequest)
}
return nil
}
func parseCID(raw string) (cid.Cid, error) {
parsed, err := cid.Parse(raw)
if err != nil || !parsed.Defined() {
return cid.Undef, fmt.Errorf("%w: invalid cid", ErrUnexpectedResponse)
}
return parsed, nil
}
func parseRecordView(view recordView) (Record, error) {
recordCID, err := parseCID(view.CID)
if err != nil {
return Record{}, err
}
recordURI, err := syntax.ParseATURI(view.URI)
if err != nil {
return Record{}, fmt.Errorf("%w: invalid record uri", ErrUnexpectedResponse)
}
value := bytes.TrimSpace(view.Value)
if len(value) == 0 || bytes.Equal(value, []byte("null")) {
return Record{}, fmt.Errorf("%w: record has no value", ErrUnexpectedResponse)
}
return Record{URI: recordURI, CID: recordCID, Value: append(json.RawMessage(nil), value...)}, nil
}
type recordView struct {
URI string `json:"uri"`
CID string `json:"cid"`
Value json.RawMessage `json:"value"`
}
func (b *basePDS) GetRecord(ctx context.Context, path RepoPath, expected *cid.Cid) (Record, error) {
if err := validatePath(path, true); err != nil {
return Record{}, err
}
query := url.Values{}
query.Set("repo", path.Repo.String())
query.Set("collection", path.Collection.String())
query.Set("rkey", path.Rkey.String())
if expected != nil {
if !expected.Defined() {
return Record{}, fmt.Errorf("%w: undefined cid", ErrInvalidRequest)
}
query.Set("cid", expected.String())
}
var out recordView
if err := b.client.getJSON(ctx, "com.atproto.repo.getRecord", query, nil, &out); err != nil {
return Record{}, err
}
rec, err := parseRecordView(out)
if err != nil || expected == nil {
return rec, err
}
err = recordcid.Verify(rec.Value, expected.String(), rec.CID.String())
if errors.Is(err, recordcid.ErrOtherVersion) {
return rec, fmt.Errorf("at://%s/%s/%s: %w", path.Repo, path.Collection, path.Rkey, err)
}
if err != nil {
return Record{}, fmt.Errorf("at://%s/%s/%s: %w", path.Repo, path.Collection, path.Rkey, err)
}
rec.CID = *expected
return rec, nil
}
type writeRequest struct {
Repo string `json:"repo"`
Collection string `json:"collection"`
Rkey string `json:"rkey,omitempty"`
Record json.RawMessage `json:"record"`
SwapCommit *string `json:"swapCommit,omitempty"`
SwapRecord *string `json:"swapRecord,omitempty"`
Validate *bool `json:"validate,omitempty"`
}
type deleteRequest struct {
Repo string `json:"repo"`
Collection string `json:"collection"`
Rkey string `json:"rkey"`
SwapCommit *string `json:"swapCommit,omitempty"`
SwapRecord *string `json:"swapRecord,omitempty"`
}
type commitView struct {
CID string `json:"cid"`
Rev string `json:"rev"`
}
type writeResponse struct {
URI string `json:"uri"`
CID string `json:"cid"`
Commit *commitView `json:"commit,omitempty"`
}
func swapValue(value *cid.Cid) (*string, error) {
if value == nil {
return nil, nil
}
if !value.Defined() {
return nil, fmt.Errorf("%w: undefined swap cid", ErrInvalidRequest)
}
raw := value.String()
return &raw, nil
}
func parseCommitView(view *commitView) (*CommitRef, error) {
if view == nil {
return nil, nil
}
commitCID, err := parseCID(view.CID)
if err != nil {
return nil, err
}
rev, err := syntax.ParseTID(view.Rev)
if err != nil {
return nil, fmt.Errorf("%w: invalid commit rev", ErrUnexpectedResponse)
}
return &CommitRef{CID: commitCID, Rev: rev}, nil
}
func parseWriteResponse(out writeResponse) (WriteResult, error) {
recordURI, err := syntax.ParseATURI(out.URI)
if err != nil {
return WriteResult{}, fmt.Errorf("%w: invalid record uri", ErrUnexpectedResponse)
}
recordCID, err := parseCID(out.CID)
if err != nil {
return WriteResult{}, err
}
commit, err := parseCommitView(out.Commit)
if err != nil {
return WriteResult{}, err
}
return WriteResult{URI: recordURI, CID: recordCID, Commit: commit}, nil
}
func (b *basePDS) writeRecord(ctx context.Context, nsid string, path RepoPath, record []byte, opts WriteOptions, requireRkey bool) (WriteResult, error) {
if err := validatePath(path, requireRkey); err != nil {
return WriteResult{}, err
}
if err := validateRecord(record); err != nil {
return WriteResult{}, err
}
swapCommit, err := swapValue(opts.SwapCommit)
if err != nil {
return WriteResult{}, err
}
swapRecord, err := swapValue(opts.SwapRecord)
if err != nil {
return WriteResult{}, err
}
auth, err := b.client.credential()
if err != nil {
return WriteResult{}, err
}
request := writeRequest{
Repo: path.Repo.String(),
Collection: path.Collection.String(),
Rkey: path.Rkey.String(),
Record: append(json.RawMessage(nil), record...),
SwapCommit: swapCommit,
SwapRecord: swapRecord,
Validate: opts.Validate,
}
var out writeResponse
if err := b.client.postJSON(ctx, nsid, request, auth, &out); err != nil {
return WriteResult{}, err
}
return parseWriteResponse(out)
}
func (b *basePDS) CreateRecord(ctx context.Context, path RepoPath, record []byte, opts WriteOptions) (WriteResult, error) {
return b.writeRecord(ctx, "com.atproto.repo.createRecord", path, record, opts, false)
}
func (b *basePDS) PutRecord(ctx context.Context, path RepoPath, record []byte, opts WriteOptions) (WriteResult, error) {
return b.writeRecord(ctx, "com.atproto.repo.putRecord", path, record, opts, true)
}
func (b *basePDS) DeleteRecord(ctx context.Context, path RepoPath, opts WriteOptions) error {
if err := validatePath(path, true); err != nil {
return err
}
swapCommit, err := swapValue(opts.SwapCommit)
if err != nil {
return err
}
swapRecord, err := swapValue(opts.SwapRecord)
if err != nil {
return err
}
auth, err := b.client.credential()
if err != nil {
return err
}
request := deleteRequest{
Repo: path.Repo.String(),
Collection: path.Collection.String(),
Rkey: path.Rkey.String(),
SwapCommit: swapCommit,
SwapRecord: swapRecord,
}
return b.client.postJSON(ctx, "com.atproto.repo.deleteRecord", request, auth, nil)
}
func (b *basePDS) ListRecords(ctx context.Context, req ListRecordsRequest) (ListRecordsResult, error) {
if strings.TrimSpace(req.Repo.String()) == "" {
return ListRecordsResult{}, fmt.Errorf("%w: repo is required", ErrInvalidRequest)
}
if strings.TrimSpace(req.Collection.String()) == "" {
return ListRecordsResult{}, fmt.Errorf("%w: collection is required", ErrInvalidRequest)
}
if req.Limit < 0 || req.Limit > maxListRecordsLimit {
return ListRecordsResult{}, fmt.Errorf("%w: limit must be between 0 and 100", ErrInvalidRequest)
}
query := url.Values{}
query.Set("repo", req.Repo.String())
query.Set("collection", req.Collection.String())
if req.Cursor != "" {
query.Set("cursor", req.Cursor)
}
if req.Limit > 0 {
query.Set("limit", fmt.Sprintf("%d", req.Limit))
}
if req.Reverse {
query.Set("reverse", "true")
}
var out struct {
Records []recordView `json:"records"`
Cursor string `json:"cursor"`
}
if err := b.client.getJSON(ctx, "com.atproto.repo.listRecords", query, nil, &out); err != nil {
return ListRecordsResult{}, err
}
result := ListRecordsResult{
Records: make([]Record, 0, len(out.Records)),
Cursor: out.Cursor,
}
for _, view := range out.Records {
record, err := parseRecordView(view)
if err != nil {
return ListRecordsResult{}, err
}
result.Records = append(result.Records, record)
}
return result, nil
}
func (b *basePDS) GetRepo(ctx context.Context, did syntax.DID, since *syntax.TID) (io.ReadCloser, error) {
if strings.TrimSpace(did.String()) == "" {
return nil, fmt.Errorf("%w: did is required", ErrInvalidRequest)
}
query := url.Values{}
query.Set("did", did.String())
if since != nil {
query.Set("since", since.String())
}
body, err := b.client.get(ctx, "com.atproto.sync.getRepo", query, nil, maxRepoBytes)
if err != nil {
return nil, err
}
return io.NopCloser(bytes.NewReader(body)), nil
}
func (b *basePDS) GetLatestCommit(ctx context.Context, did syntax.DID) (cid.Cid, syntax.TID, error) {
if strings.TrimSpace(did.String()) == "" {
return cid.Undef, "", fmt.Errorf("%w: did is required", ErrInvalidRequest)
}
query := url.Values{}
query.Set("did", did.String())
var out struct {
CID string `json:"cid"`
Rev string `json:"rev"`
}
if err := b.client.getJSON(ctx, "com.atproto.sync.getLatestCommit", query, nil, &out); err != nil {
return cid.Undef, "", err
}
commitCID, err := parseCID(out.CID)
if err != nil {
return cid.Undef, "", err
}
rev, err := syntax.ParseTID(out.Rev)
if err != nil {
return cid.Undef, "", fmt.Errorf("%w: invalid rev", ErrUnexpectedResponse)
}
return commitCID, rev, nil
}
func (b *basePDS) SubscribeRepos(ctx context.Context, cursor *int64) (RepoEventStream, error) {
if b.dial == nil {
return nil, fmt.Errorf("%w: subscriptions are not configured", ErrInvalidConfig)
}
return newRepoEventStream(ctx, cursor, b.dial)
}
type createSessionRequest struct {
Identifier string `json:"identifier"`
Password string `json:"password"`
}
type createAccountRequest struct {
Handle string `json:"handle"`
Email string `json:"email,omitempty"`
Password string `json:"password,omitempty"`
InviteCode string `json:"inviteCode,omitempty"`
}
type sessionResponse struct {
AccessJWT string `json:"accessJwt"`
RefreshJWT string `json:"refreshJwt"`
Handle string `json:"handle"`
DID string `json:"did"`
Email string `json:"email"`
Active bool `json:"active"`
}
type getSessionResponse struct {
DID string `json:"did"`
Handle string `json:"handle"`
Email string `json:"email"`
Active bool `json:"active"`
}
func (b *basePDS) CreateSession(ctx context.Context, identifier, password string) (Session, error) {
if strings.TrimSpace(identifier) == "" || strings.TrimSpace(password) == "" {
return Session{}, fmt.Errorf("%w: identifier and password are required", ErrInvalidRequest)
}
var out sessionResponse
request := createSessionRequest{Identifier: identifier, Password: password}
if err := b.client.postJSON(ctx, "com.atproto.server.createSession", request, nil, &out); err != nil {
return Session{}, err
}
session, err := sessionFromResponse(out)
if err != nil {
return Session{}, err
}
b.client.session.set(session)
return session, nil
}
func (b *basePDS) CreateAccount(ctx context.Context, req CreateAccountRequest) (Session, error) {
identifier := strings.TrimSpace(req.Identifier)
if identifier == "" || strings.TrimSpace(req.Password) == "" {
return Session{}, fmt.Errorf("%w: identifier and password are required", ErrInvalidRequest)
}
request := createAccountRequest{
Handle: identifier,
Email: strings.TrimSpace(req.Email),
Password: req.Password,
InviteCode: strings.TrimSpace(req.InviteCode),
}
var out sessionResponse
if err := b.client.postJSON(ctx, "com.atproto.server.createAccount", request, nil, &out); err != nil {
return Session{}, err
}
session, err := sessionFromResponse(out)
if err != nil {
return Session{}, err
}
b.client.session.set(session)
return session, nil
}
func sessionFromResponse(out sessionResponse) (Session, error) {
did, err := syntax.ParseDID(strings.TrimSpace(out.DID))
if err != nil {
return Session{}, fmt.Errorf("%w: session response returned an invalid did", ErrUnexpectedResponse)
}
if out.AccessJWT == "" {
return Session{}, fmt.Errorf("%w: session response returned no access token", ErrUnexpectedResponse)
}
return Session{
DID: did,
Handle: out.Handle,
Email: out.Email,
AccessJWT: out.AccessJWT,
RefreshJWT: out.RefreshJWT,
Active: out.Active,
}, nil
}
func (b *basePDS) GetSession(ctx context.Context) (Session, error) {
auth, err := b.client.credential()
if err != nil {
return Session{}, err
}
var out getSessionResponse
if err := b.client.getJSON(ctx, "com.atproto.server.getSession", nil, auth, &out); err != nil {
return Session{}, err
}
did, err := syntax.ParseDID(strings.TrimSpace(out.DID))
if err != nil {
return Session{}, fmt.Errorf("%w: getSession returned an invalid did", ErrUnexpectedResponse)
}
stored := b.client.session.snapshot()
return Session{
DID: did,
Handle: out.Handle,
Email: out.Email,
AccessJWT: stored.AccessJWT,
RefreshJWT: stored.RefreshJWT,
Active: out.Active,
}, nil
}
func (b *basePDS) DeleteSession(ctx context.Context) error {
auth := b.client.auth
if stored := b.client.session.snapshot(); stored.RefreshJWT != "" {
auth = bearer(stored.RefreshJWT)
} else if stored.AccessJWT != "" {
auth = bearer(stored.AccessJWT)
}
if auth == nil {
return fmt.Errorf("%w: no refresh or access token is available", ErrAuthenticationRequired)
}
if err := b.client.postJSON(ctx, "com.atproto.server.deleteSession", nil, auth, nil); err != nil {
return err
}
b.client.session.clear()
return nil
}