PostView counts

main.go

···
 				go func(i int, raw string) {
 					defer wg.Done()
 
-					post, _, _ := appbskyfeeddefs.PostView(ctx, raw, sl, BSKYIMAGECDN_URL)
+					post, _, _ := appbskyfeeddefs.PostView(ctx, raw, sl, cs, BSKYIMAGECDN_URL)
 
 					results[i].view = post
 				}(i, raw)
···
 
 			skeletonposts := feekskeleton.Feed
 
-			type result struct {
-				view *appbsky.FeedDefs_FeedViewPost
-			}
-
-			results := make([]result, len(skeletonposts))
-
-			var wg sync.WaitGroup
-			wg.Add(len(skeletonposts))
-
-			for i, raw := range skeletonposts {
-				go func(i int, raw appbsky.FeedDefs_SkeletonFeedPost) {
-					defer wg.Done()
-
-					post, _, err := appbskyfeeddefs.PostView(ctx, raw.Post, sl, BSKYIMAGECDN_URL)
-					if err != nil || post == nil {
-						return
+			concurrentResults := MapConcurrent(
+				ctx,
+				skeletonposts,
+				20,
+				func(ctx context.Context, raw *appbsky.FeedDefs_SkeletonFeedPost) (*appbsky.FeedDefs_FeedViewPost, error) {
+					post, _, err := appbskyfeeddefs.PostView(ctx, raw.Post, sl, cs, BSKYIMAGECDN_URL)
+					if err != nil {
+						return nil, err
+					}
+					if post == nil {
+						return nil, fmt.Errorf("post not found")
 					}
 
-					feedviewpost := &appbsky.FeedDefs_FeedViewPost{
+					return &appbsky.FeedDefs_FeedViewPost{
 						// FeedContext *string                       `json:"feedContext,omitempty" cborgen:"feedContext,omitempty"`
 						// Post        *FeedDefs_PostView            `json:"post" cborgen:"post"`
 						Post: post,
···
 						// Reply       *FeedDefs_ReplyRef            `json:"reply,omitempty" cborgen:"reply,omitempty"`
 						// // reqId: Unique identifier per request that may be passed back alongside interactions.
 						// ReqId *string `json:"reqId,omitempty" cborgen:"reqId,omitempty"`
-
-					}
-
-					results[i].view = feedviewpost
-				}(i, *raw)
-			}
-
-			wg.Wait()
+					}, nil
+				},
+			)
 
 			// build final slice
-			out := make([]*appbsky.FeedDefs_FeedViewPost, 0, len(results))
-			for _, r := range results {
-				if r.view != nil && r.view.Post != nil {
-					out = append(out, r.view)
+			out := make([]*appbsky.FeedDefs_FeedViewPost, 0, len(concurrentResults))
+			for _, r := range concurrentResults {
+				if r.Err == nil && r.Value != nil && r.Value.Post != nil {
+					out = append(out, r.Value)
 				}
 			}
 

shims/lex/app/bsky/feed/defs/postview.go

···
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.org/whey.party/red-dwarf-server/microcosm"
+	"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
 
 	//"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
 	//"tangled.org/whey.party/red-dwarf-server/microcosm/slingshot"
···
 	"tangled.org/whey.party/red-dwarf-server/shims/utils"
 )
 
-func PostView(ctx context.Context, postaturi string, sl *microcosm.MicrocosmClient, imgcdn string) (*appbsky.FeedDefs_PostView, *appbsky.FeedPost, error) {
+func PostView(ctx context.Context, postaturi string, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string) (*appbsky.FeedDefs_PostView, *appbsky.FeedPost, error) {
 	aturi, err := syntax.ParseATURI(postaturi)
 	if err != nil {
 		return nil, nil, err
···
 
 	lexicontypedecoder := &util.LexiconTypeDecoder{Val: &postRecord}
 
-	fakecount := int64(-1)
+	links, err := constellation.LegacyLinksAll(ctx, cs, postRecordResponse.Uri)
+	var likeCount int64
+	if links != nil &&
+		links.Links != nil {
+		like, ok := links.Links["app.bsky.feed.like"]
+		if ok && like != nil {
+			subj, ok := like[".subject.uri"]
+			if ok {
+				likeCount = int64(subj.Records)
+			}
+		}
+	}
+	var repostCount int64
+	if links != nil &&
+		links.Links != nil {
+		like, ok := links.Links["app.bsky.repost.like"]
+		if ok && like != nil {
+			subj, ok := like[".subject.uri"]
+			if ok {
+				repostCount = int64(subj.Records)
+			}
+		}
+	}
+	var replyCount int64
+	if links != nil &&
+		links.Links != nil {
+		like, ok := links.Links["app.bsky.feed.post"]
+		if ok && like != nil {
+			subj, ok := like[".reply.parent.uri"]
+			if ok {
+				replyCount = int64(subj.Records)
+			}
+		}
+	}
+	var quoteCount_noEmbed int64
+	if links != nil &&
+		links.Links != nil {
+		like, ok := links.Links["app.bsky.feed.like"]
+		if ok && like != nil {
+			subj, ok := like[".embed.record.uri"]
+			if ok {
+				likeCount = int64(subj.Records)
+			}
+		}
+	}
+	var quoteCount_withEmbed int64
+	if links != nil &&
+		links.Links != nil {
+		like, ok := links.Links["app.bsky.feed.like"]
+		if ok && like != nil {
+			subj, ok := like[".embed.record.record.uri"]
+			if ok {
+				likeCount = int64(subj.Records)
+			}
+		}
+	}
+	quoteCount := quoteCount_noEmbed + quoteCount_withEmbed
+
+	//fakecount := int64(-1)
 
 	return &appbsky.FeedDefs_PostView{
 		// LexiconTypeID string                      `json:"$type" cborgen:"$type,const=app.bsky.feed.defs#postView"`
···
 		IndexedAt: postRecord.CreatedAt,
 		// Labels      []*comatproto.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
 		// LikeCount   *int64                        `json:"likeCount,omitempty" cborgen:"likeCount,omitempty"`
-		LikeCount: &fakecount,
+		LikeCount: &likeCount,
 		// QuoteCount  *int64                        `json:"quoteCount,omitempty" cborgen:"quoteCount,omitempty"`
-		QuoteCount: &fakecount,
+		QuoteCount: &quoteCount,
 		// Record      *lexutil.LexiconTypeDecoder   `json:"record" cborgen:"record"`
 		Record: lexicontypedecoder,
 		// ReplyCount  *int64                        `json:"replyCount,omitempty" cborgen:"replyCount,omitempty"`
-		ReplyCount: &fakecount,
+		ReplyCount: &replyCount,
 		// RepostCount *int64                        `json:"repostCount,omitempty" cborgen:"repostCount,omitempty"`
-		RepostCount: &fakecount,
+		RepostCount: &repostCount,
 		// Threadgate  *FeedDefs_ThreadgateView      `json:"threadgate,omitempty" cborgen:"threadgate,omitempty"`
 		// Uri         string                        `json:"uri" cborgen:"uri"`
 		Uri: postRecordResponse.Uri,

utils.go

···
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"strings"
+	"sync"
 )
 
 type DIDDocument struct {
···
 
 	return &doc, nil
 }
+
+type AsyncResult[T any] struct {
+	Value T
+	Err   error
+}
+
+func MapConcurrent[T any, R any](
+	ctx context.Context,
+	items []T,
+	concurrencyLimit int,
+	mapper func(context.Context, T) (R, error),
+) []AsyncResult[R] {
+	if len(items) == 0 {
+		return nil
+	}
+
+	results := make([]AsyncResult[R], len(items))
+	var wg sync.WaitGroup
+
+	sem := make(chan struct{}, concurrencyLimit)
+
+	for i, item := range items {
+		wg.Add(1)
+		go func(idx int, input T) {
+			defer wg.Done()
+
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			if ctx.Err() != nil {
+				results[idx] = AsyncResult[R]{Err: ctx.Err()}
+				return
+			}
+
+			val, err := mapper(ctx, input)
+			results[idx] = AsyncResult[R]{Value: val, Err: err}
+		}(i, item)
+	}
+
+	wg.Wait()
+	return results
+}
+
+func RunConcurrent(tasks ...func() error) []error {
+	var wg sync.WaitGroup
+	errs := make([]error, len(tasks))
+
+	wg.Add(len(tasks))
+
+	for i, task := range tasks {
+		go func(i int, t func() error) {
+			defer wg.Done()
+			if err := t(); err != nil {
+				errs[i] = err
+			}
+		}(i, task)
+	}
+
+	wg.Wait()
+	return errs
+}