microcosm api client

main.go

···
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"time"
 
+	"tangled.org/whey.party/rdcs/microcosm/constellation"
+	"tangled.org/whey.party/rdcs/microcosm/slingshot"
 	"tangled.org/whey.party/rdcs/sticket"
+
 	// "github.com/bluesky-social/indigo/atproto/atclient"
 	// comatproto "github.com/bluesky-social/indigo/api/atproto"
 	// appbsky "github.com/bluesky-social/indigo/api/bsky"
 	// "github.com/bluesky-social/indigo/atproto/atclient"
 	// "github.com/bluesky-social/indigo/atproto/identity"
 	// "github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/api/agnostic"
 	// "github.com/bluesky-social/jetstream/pkg/models"
 )
 
···
 func main() {
 	fmt.Fprintf(os.Stdout, "RDCS started")
 
+	ctx := context.Background()
 	mailbox := sticket.New()
+	sl := slingshot.NewSlingshot(SLINGSHOT_URL)
+	cs := constellation.NewConstellation(CONSTELLATION_URL)
+	// spacedust is type definitions only
+	// jetstream types is probably available from jetstream/pkg/models
+
+	responsewow, _ := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.feed.profile", "did:plc:44ybard66vv44zksje25o7dz", "self")
+
+	fmt.Fprintf(os.Stdout, responsewow.Uri)
 
 	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
 		mailbox.HandleWS(&w, r)

microcosm/constellation/constellation.go

···
+package constellation
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/lex/util"
+	"tangled.org/whey.party/rdcs/microcosm"
+)
+
+func NewConstellation(host string) *microcosm.MicrocosmClient {
+	return microcosm.NewMicrocosm(host)
+}
+
+type ConstellationRecord struct {
+	Did        string `json:"did" cborgen:"did"`
+	Collection string `json:"collection" cborgen:"collection"`
+	Rkey       string `json:"rkey" cborgen:"rkey"`
+}
+
+type GetBacklinks_Output struct {
+	Total   int                   `json:"total" cborgen:"total"`
+	Records []ConstellationRecord `json:"records" cborgen:"records"`
+	Cursor  *string               `json:"cursor" cborgen:"cursor"`
+}
+
+func GetBacklinks(ctx context.Context, c util.LexClient, subject string, source string, did []string, limit *int, cursor *string) (*GetBacklinks_Output, error) {
+	var out GetBacklinks_Output
+
+	params := map[string]interface{}{
+		"subject": subject,
+		"source":  source,
+	}
+
+	if len(did) > 0 {
+		params["did"] = did
+	}
+
+	if limit != nil {
+		params["limit"] = *limit
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.LexDo(ctx, util.Query, "", "blue.microcosm.links.getBacklinks", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+type TooManyItem struct {
+	Subject  string `json:"subject" cborgen:"subject"`
+	Total    int    `json:"total" cborgen:"total"`
+	Distinct int    `json:"distinct" cborgen:"distinct"`
+}
+type GetTooManyCounts_Output struct {
+	CountsByOtherSubject []TooManyItem `json:"counts_by_other_subject" cborgen:"counts_by_other_subject"`
+	Cursor               *string       `json:"cursor" cborgen:"cursor"`
+}
+
+func GetTooManyCounts(ctx context.Context, c util.LexClient, subject string, source string, pathToOther string, did []string, otherSubject []string, limit *int, cursor *string) (*GetTooManyCounts_Output, error) {
+	var out GetTooManyCounts_Output
+
+	params := map[string]interface{}{
+		"subject":     subject,
+		"source":      source,
+		"pathToOther": pathToOther,
+	}
+
+	if len(did) > 0 {
+		params["did"] = did
+	}
+
+	if len(otherSubject) > 0 {
+		params["otherSubject"] = otherSubject
+	}
+
+	if limit != nil {
+		params["limit"] = *limit
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.LexDo(ctx, util.Query, "", "blue.microcosm.links.getManyToManyCounts", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+// todo: implement the non-xrpc routes.
+// prerequisites: a bespoke new api request system that does not use LexDo
+
+type LegacyLinks_Output struct {
+	Total          int                   `json:"total" cborgen:"total"`
+	LinkingRecords []ConstellationRecord `json:"linking_records" cborgen:"linking_records"`
+	Cursor         *string               `json:"cursor" cborgen:"cursor"`
+}
+
+// Deprecated: use GetBackLinks
+func LegacyLinks(ctx context.Context, c *microcosm.MicrocosmClient, target string, collection string, path string, did []string, limit *int, cursor *string) (*LegacyLinks_Output, error) {
+	var out LegacyLinks_Output
+
+	params := map[string]interface{}{
+		"target":     target,
+		"collection": collection,
+		"path":       path,
+	}
+
+	if len(did) > 0 {
+		params["did"] = did
+	}
+
+	if limit != nil {
+		params["limit"] = *limit
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.PathDo(ctx, util.Query, "", "/links", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+type LegacyLinksDistinctDids_Output struct {
+	Total          int      `json:"total" cborgen:"total"`
+	LinkingRecords []string `json:"linking_records" cborgen:"linking_records"`
+	Cursor         *string  `json:"cursor" cborgen:"cursor"`
+}
+
+func LegacyLinksDistinctDids(ctx context.Context, c *microcosm.MicrocosmClient, target string, collection string, path string, cursor *string) (*LegacyLinksDistinctDids_Output, error) {
+	var out LegacyLinksDistinctDids_Output
+
+	params := map[string]interface{}{
+		"target":     target,
+		"collection": collection,
+		"path":       path,
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.PathDo(ctx, util.Query, "", "/links/distinct-dids", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+type ConstellationCount_Output struct {
+	Total int `json:"total" cborgen:"total"`
+}
+
+func LegacyLinksCount(ctx context.Context, c *microcosm.MicrocosmClient, target string, collection string, path string, cursor *string) (*ConstellationCount_Output, error) {
+	var out ConstellationCount_Output
+
+	params := map[string]interface{}{
+		"target":     target,
+		"collection": collection,
+		"path":       path,
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.PathDo(ctx, util.Query, "", "/links/count", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+func LegacyLinksCountDistinctDids(ctx context.Context, c *microcosm.MicrocosmClient, target string, collection string, path string, cursor *string) (*ConstellationCount_Output, error) {
+	var out ConstellationCount_Output
+
+	params := map[string]interface{}{
+		"target":     target,
+		"collection": collection,
+		"path":       path,
+	}
+
+	if cursor != nil {
+		params["cursor"] = *cursor
+	}
+
+	if err := c.PathDo(ctx, util.Query, "", "/links/count/distinct-dids", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+type LinkStats struct {
+	Records      int `json:"records"`
+	DistinctDIDs int `json:"distinct_dids"`
+}
+
+type ConstellationAll_Output struct {
+	Links map[string]map[string]LinkStats `json:"links"`
+}
+
+func LegacyLinksAll(ctx context.Context, c *microcosm.MicrocosmClient, target string) (*ConstellationAll_Output, error) {
+	var out ConstellationAll_Output
+
+	params := map[string]interface{}{
+		"target": target,
+	}
+
+	if err := c.PathDo(ctx, util.Query, "", "/links/all", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

microcosm/microcosm.go

···
+package microcosm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	atpclient "github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+)
+
+type MicrocosmClient struct {
+	// Inner HTTP client. May be customized after the overall [MicrocosmClient] struct is created; for example to set a default request timeout.
+	Client *http.Client
+
+	// Host URL prefix: scheme, hostname, and port. This field is required.
+	Host string
+
+	// Optional HTTP headers which will be included in all requests. Only a single value per key is included; request-level headers will override any client-level defaults.
+	Headers http.Header
+}
+
+func NewMicrocosm(host string) *MicrocosmClient {
+	// validate cfg if needed
+	return &MicrocosmClient{
+		Client: http.DefaultClient,
+		Host:   host,
+		Headers: map[string][]string{
+			"User-Agent": []string{"microcosm-rdcs"},
+		},
+	}
+}
+
+func (c *MicrocosmClient) LexDo(ctx context.Context, method string, inputEncoding string, endpoint string, params map[string]any, bodyData any, out any) error {
+	// some of the code here is copied from indigo:xrpc/xrpc.go
+
+	nsid, err := syntax.ParseNSID(endpoint)
+	if err != nil {
+		return err
+	}
+
+	var body io.Reader
+	if bodyData != nil {
+		if rr, ok := bodyData.(io.Reader); ok {
+			body = rr
+		} else {
+			b, err := json.Marshal(bodyData)
+			if err != nil {
+				return err
+			}
+
+			body = bytes.NewReader(b)
+			if inputEncoding == "" {
+				inputEncoding = "application/json"
+			}
+		}
+	}
+
+	req := NewAPIRequest(method, nsid, body)
+
+	if inputEncoding != "" {
+		req.Headers.Set("Content-Type", inputEncoding)
+	}
+
+	if params != nil {
+		qp, err := atpclient.ParseParams(params)
+		if err != nil {
+			return err
+		}
+		req.QueryParams = qp
+	}
+
+	resp, err := c.Do(ctx, req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if !(resp.StatusCode >= 200 && resp.StatusCode < 300) {
+		var eb atpclient.ErrorBody
+		if err := json.NewDecoder(resp.Body).Decode(&eb); err != nil {
+			return &atpclient.APIError{StatusCode: resp.StatusCode}
+		}
+		return eb.APIError(resp.StatusCode)
+	}
+
+	if out == nil {
+		// drain body before returning
+		io.ReadAll(resp.Body)
+		return nil
+	}
+
+	if buf, ok := out.(*bytes.Buffer); ok {
+		if resp.ContentLength < 0 {
+			_, err := io.Copy(buf, resp.Body)
+			if err != nil {
+				return fmt.Errorf("reading response body: %w", err)
+			}
+		} else {
+			n, err := io.CopyN(buf, resp.Body, resp.ContentLength)
+			if err != nil {
+				return fmt.Errorf("reading length delimited response body (%d < %d): %w", n, resp.ContentLength, err)
+			}
+		}
+	} else {
+		if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
+			return fmt.Errorf("failed decoding JSON response body: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (c *MicrocosmClient) Do(ctx context.Context, req *atpclient.APIRequest) (*http.Response, error) {
+
+	if c.Client == nil {
+		c.Client = http.DefaultClient
+	}
+
+	httpReq, err := req.HTTPRequest(ctx, c.Host, c.Headers)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp *http.Response
+	resp, err = c.Client.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+func NewAPIRequest(method string, endpoint syntax.NSID, body io.Reader) *atpclient.APIRequest {
+	req := atpclient.APIRequest{
+		Method:      method,
+		Endpoint:    endpoint,
+		Headers:     map[string][]string{},
+		QueryParams: map[string][]string{},
+	}
+
+	// logic to turn "whatever io.Reader we are handed" in to something relatively re-tryable (using GetBody)
+	if body != nil {
+		// NOTE: http.NewRequestWithContext already handles GetBody() as well as ContentLength for specific types like bytes.Buffer and strings.Reader. We just want to add io.Seeker here, for things like files-on-disk.
+		switch v := body.(type) {
+		case io.Seeker:
+			req.Body = io.NopCloser(body)
+			req.GetBody = func() (io.ReadCloser, error) {
+				v.Seek(0, 0)
+				return io.NopCloser(body), nil
+			}
+		default:
+			req.Body = body
+		}
+	}
+	return &req
+}
+
+// PathDo performs an HTTP request to an arbitrary path (no /xrpc/ prefix enforcement).
+func (c *MicrocosmClient) PathDo(ctx context.Context, method string, inputEncoding string, path string, params map[string]any, bodyData any, out any) error {
+	// 1. Prepare the request body
+	var body io.Reader
+	if bodyData != nil {
+		if rr, ok := bodyData.(io.Reader); ok {
+			body = rr
+		} else {
+			b, err := json.Marshal(bodyData)
+			if err != nil {
+				return err
+			}
+			body = bytes.NewReader(b)
+			if inputEncoding == "" {
+				inputEncoding = "application/json"
+			}
+		}
+	}
+
+	// 2. Construct the full URL
+	// We handle slash joining carefully to avoid double slashes or missing slashes
+	baseURL := strings.TrimRight(c.Host, "/")
+	cleanPath := strings.TrimLeft(path, "/")
+	fullURLStr := fmt.Sprintf("%s/%s", baseURL, cleanPath)
+
+	// 3. Prepare Query Parameters
+	// We reuse the indigo parser for convenience, but we must apply them manually to the URL
+	var queryParams url.Values
+	if params != nil {
+		qp, err := atpclient.ParseParams(params)
+		if err != nil {
+			return err
+		}
+		queryParams = make(url.Values)
+		for k, v := range qp {
+			for _, val := range v {
+				queryParams.Add(k, val)
+			}
+		}
+	}
+
+	if len(queryParams) > 0 {
+		// Verify the URL parses correctly so we can attach params
+		u, err := url.Parse(fullURLStr)
+		if err != nil {
+			return fmt.Errorf("invalid url: %w", err)
+		}
+		u.RawQuery = queryParams.Encode()
+		fullURLStr = u.String()
+	}
+
+	// 4. Create the Standard HTTP Request
+	req, err := http.NewRequestWithContext(ctx, method, fullURLStr, body)
+	if err != nil {
+		return err
+	}
+
+	// 5. Apply Headers
+	// Apply default client headers
+	for k, v := range c.Headers {
+		for _, val := range v {
+			req.Header.Add(k, val)
+		}
+	}
+	// Apply specific content type if set
+	if inputEncoding != "" {
+		req.Header.Set("Content-Type", inputEncoding)
+	}
+
+	// 6. Execute Request
+	// Note: We access c.Client directly because c.Do() expects an XRPC-specific APIRequest
+	if c.Client == nil {
+		c.Client = http.DefaultClient
+	}
+	resp, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	// 7. Handle Response (Mirrors LexDo logic)
+	if !(resp.StatusCode >= 200 && resp.StatusCode < 300) {
+		// Try to decode generic error body, fallback to status code error
+		var eb atpclient.ErrorBody
+		if err := json.NewDecoder(resp.Body).Decode(&eb); err != nil {
+			return fmt.Errorf("http request failed: %s", resp.Status)
+		}
+		return eb.APIError(resp.StatusCode)
+	}
+
+	if out == nil {
+		io.ReadAll(resp.Body)
+		return nil
+	}
+
+	if buf, ok := out.(*bytes.Buffer); ok {
+		if resp.ContentLength < 0 {
+			_, err := io.Copy(buf, resp.Body)
+			if err != nil {
+				return fmt.Errorf("reading response body: %w", err)
+			}
+		} else {
+			n, err := io.CopyN(buf, resp.Body, resp.ContentLength)
+			if err != nil {
+				return fmt.Errorf("reading length delimited response body (%d < %d): %w", n, resp.ContentLength, err)
+			}
+		}
+	} else {
+		if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
+			return fmt.Errorf("failed decoding JSON response body: %w", err)
+		}
+	}
+
+	return nil
+}

microcosm/slingshot/slingshot.go

···
+package slingshot
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/api/agnostic"
+	"github.com/bluesky-social/indigo/lex/util"
+	"tangled.org/whey.party/rdcs/microcosm"
+)
+
+func NewSlingshot(host string) *microcosm.MicrocosmClient {
+	return microcosm.NewMicrocosm(host)
+}
+
+type ResolveMiniDoc_Output struct {
+	Did        string `json:"did" cborgen:"did"`
+	Handle     string `json:"handle" cborgen:"handle"`
+	Pds        string `json:"pds" cborgen:"pds"`
+	SigningKey string `json:"signing_key" cborgen:"signing_key"`
+}
+
+// get record also works here, but you should import it from indigo/api/agnostic (RepoGetRecord)
+
+func RepoGetUriRecord(ctx context.Context, c util.LexClient, cid string, at_uri string) (*agnostic.RepoGetRecord_Output, error) {
+	var out agnostic.RepoGetRecord_Output
+
+	params := map[string]interface{}{
+		"at_uri": at_uri,
+	}
+	if cid != "" {
+		params["cid"] = cid
+	}
+	if err := c.LexDo(ctx, util.Query, "", "com.bad-example.repo.getUriRecord", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}
+
+// resolve handle also works here, but you should import it from indigo/atproto/identity (ResolveHandle)
+
+func ResolveMiniDoc(ctx context.Context, c util.LexClient, repo string) (*ResolveMiniDoc_Output, error) {
+	var out ResolveMiniDoc_Output
+
+	params := map[string]interface{}{
+		"identifier": repo,
+	}
+	if err := c.LexDo(ctx, util.Query, "", "com.bad-example.identity.resolveMiniDoc", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

microcosm/spacedust/spacedust.go

···
+package spacedust
+
+type Spacedust_Event struct {
+	Kind   string         `json:"kind" cborgen:"kind,const=link"`
+	Origin string         `json:"origin" cborgen:"origin,const=live|replay|backfill"`
+	Link   Spacedust_Link `json:"link" cborgen:"link"`
+}
+
+type Spacedust_Link struct {
+	Operation    string `json:"operation" cborgen:"operation,const=create|delete"`
+	Source       string `json:"source" cborgen:"source"`
+	SourceRecord string `json:"source_record" cborgen:"source_record"`
+	SourceRev    string `json:"source_rev" cborgen:"source_rev"`
+	Subject      string `json:"subject" cborgen:"subject"`
+}
+
+type Spacedust_Query struct {
+	WantedSources     []string `json:"wantedSources" cborgen:"wantedSources"`
+	WantedSubjectDids []string `json:"wantedSubjectDids" cborgen:"wantedSubjectDids"`
+	WantedSubjects    []string `json:"wantedSubjects" cborgen:"wantedSubjects"`
+	Instant           bool     `json:"instant" cborgen:"instant"`
+}