viewer state hydration

hydration/actor.go

···
 
 	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/whyrusleeping/market/models"
 )
 
 // ActorInfo contains hydrated actor information
···
 	FollowCount   int64
 	FollowerCount int64
 	PostCount     int64
+	ViewerState   *bsky.ActorDefs_ViewerState
 }
 
-func (h *Hydrator) HydrateActorDetailed(ctx context.Context, did string) (*ActorInfoDetailed, error) {
+func (h *Hydrator) HydrateActorDetailed(ctx context.Context, did string, viewer string) (*ActorInfoDetailed, error) {
 	act, err := h.HydrateActor(ctx, did)
 	if err != nil {
 		return nil, err
···
 	}
 
 	var wg sync.WaitGroup
-	wg.Add(3)
-	go func() {
-		defer wg.Done()
+	wg.Go(func() {
 		c, err := h.getFollowCountForUser(ctx, did)
 		if err != nil {
 			slog.Error("failed to get follow count", "did", did, "error", err)
 		}
 		actd.FollowCount = c
-	}()
-	go func() {
-		defer wg.Done()
+	})
+	wg.Go(func() {
 		c, err := h.getFollowerCountForUser(ctx, did)
 		if err != nil {
 			slog.Error("failed to get follower count", "did", did, "error", err)
 		}
 		actd.FollowerCount = c
-	}()
-	go func() {
-		defer wg.Done()
+	})
+	wg.Go(func() {
 		c, err := h.getPostCountForUser(ctx, did)
 		if err != nil {
 			slog.Error("failed to get post count", "did", did, "error", err)
 		}
 		actd.PostCount = c
-	}()
+	})
+
+	if viewer != "" {
+		wg.Go(func() {
+			vs, err := h.getProfileViewerState(ctx, did, viewer)
+			if err != nil {
+				slog.Error("failed to get viewer state", "did", did, "viewer", viewer, "error", err)
+			}
+			actd.ViewerState = vs
+		})
+	}
+
 	wg.Wait()
 
 	return &actd, nil
+}
+
+func (h *Hydrator) getProfileViewerState(ctx context.Context, did, viewer string) (*bsky.ActorDefs_ViewerState, error) {
+	vs := &bsky.ActorDefs_ViewerState{}
+
+	var wg sync.WaitGroup
+
+	// Check if viewer is blocked by the target account
+	wg.Go(func() {
+		blockedBy, err := h.getBlockPair(ctx, did, viewer)
+		if err != nil {
+			slog.Error("failed to get blockedBy relationship", "did", did, "viewer", viewer, "error", err)
+			return
+		}
+
+		if blockedBy != nil {
+			v := true
+			vs.BlockedBy = &v
+		}
+	})
+
+	// Check if viewer is blocking the target account
+	wg.Go(func() {
+		blocking, err := h.getBlockPair(ctx, viewer, did)
+		if err != nil {
+			slog.Error("failed to get blocking relationship", "did", did, "viewer", viewer, "error", err)
+			return
+		}
+
+		if blocking != nil {
+			uri := fmt.Sprintf("at://%s/app.bsky.graph.block/%s", viewer, blocking.Rkey)
+			vs.Blocking = &uri
+		}
+	})
+
+	// Check if viewer is following the target account
+	wg.Go(func() {
+		following, err := h.getFollowPair(ctx, viewer, did)
+		if err != nil {
+			slog.Error("failed to get following relationship", "did", did, "viewer", viewer, "error", err)
+			return
+		}
+
+		if following != nil {
+			uri := fmt.Sprintf("at://%s/app.bsky.graph.follow/%s", viewer, following.Rkey)
+			vs.Following = &uri
+		}
+	})
+
+	// Check if target account is following the viewer
+	wg.Go(func() {
+		followedBy, err := h.getFollowPair(ctx, did, viewer)
+		if err != nil {
+			slog.Error("failed to get followedBy relationship", "did", did, "viewer", viewer, "error", err)
+			return
+		}
+
+		if followedBy != nil {
+			uri := fmt.Sprintf("at://%s/app.bsky.graph.follow/%s", did, followedBy.Rkey)
+			vs.FollowedBy = &uri
+		}
+	})
+
+	wg.Wait()
+
+	return vs, nil
+}
+
+func (h *Hydrator) getBlockPair(ctx context.Context, a, b string) (*models.Block, error) {
+	var blk models.Block
+	if err := h.db.Raw("SELECT * FROM blocks WHERE author = (SELECT id FROM repos WHERE did = ?) AND subject = (SELECT id FROM repos WHERE did = ?)", a, b).Scan(&blk).Error; err != nil {
+		return nil, err
+	}
+	if blk.ID == 0 {
+		return nil, nil
+	}
+
+	return &blk, nil
+}
+
+func (h *Hydrator) getFollowPair(ctx context.Context, a, b string) (*models.Follow, error) {
+	var fol models.Follow
+	if err := h.db.Raw("SELECT * FROM follows WHERE author = (SELECT id FROM repos WHERE did = ?) AND subject = (SELECT id FROM repos WHERE did = ?)", a, b).Scan(&fol).Error; err != nil {
+		return nil, err
+	}
+	if fol.ID == 0 {
+		return nil, nil
+	}
+
+	return &fol, nil
 }
 
 func (h *Hydrator) getFollowCountForUser(ctx context.Context, did string) (int64, error) {

pgbackend.go

···
 	. "github.com/whyrusleeping/konbini/models"
 )
 
+func (b *PostgresBackend) DidToID(ctx context.Context, did string) (uint, error) {
+	r, err := b.getOrCreateRepo(ctx, did)
+	if err != nil {
+		return 0, err
+	}
+
+	return r.ID, nil
+}
+
 func (b *PostgresBackend) getOrCreateRepo(ctx context.Context, did string) (*Repo, error) {
 	r, ok := b.repoCache.Get(did)
 	if !ok {

views/actor.go

···
 	view.FollowsCount = &actor.FollowCount
 	view.PostsCount = &actor.PostCount
 
+	// Add viewer state if available
+	if actor.ViewerState != nil {
+		view.Viewer = actor.ViewerState
+	}
+
 	return view
 }
 

xrpc/actor/getProfile.go

···
 
 	ctx := c.Request().Context()
 
+	viewer, _ := c.Get("viewer").(string)
+
 	// Resolve actor to DID
 	did, err := hydrator.ResolveDID(ctx, actorParam)
 	if err != nil {
···
 	}
 
 	// Hydrate actor info
-	actorInfo, err := hydrator.HydrateActorDetailed(ctx, did)
+	actorInfo, err := hydrator.HydrateActorDetailed(ctx, did, viewer)
 	if err != nil {
 		return c.JSON(http.StatusNotFound, map[string]interface{}{
 			"error":   "ActorNotFound",

xrpc/actor/getProfiles.go

···
 	}
 
 	ctx := c.Request().Context()
+	viewer, _ := c.Get("viewer").(string)
 
 	// Resolve all actors to DIDs and hydrate profiles
 	profiles := make([]*bsky.ActorDefs_ProfileViewDetailed, 0, len(actors))
···
 		}
 
 		// Hydrate actor info
-		actorInfo, err := hydrator.HydrateActorDetailed(ctx, did)
+		actorInfo, err := hydrator.HydrateActorDetailed(ctx, did, viewer)
 		if err != nil {
 			// Skip actors that can't be hydrated
 			continue

xrpc/server.go

···
 	// app.bsky.actor.*
 	xrpcGroup.GET("/app.bsky.actor.getProfile", func(c echo.Context) error {
 		return actor.HandleGetProfile(c, s.hydrator)
-	})
+	}, s.optionalAuth)
 	xrpcGroup.GET("/app.bsky.actor.getProfiles", func(c echo.Context) error {
 		return actor.HandleGetProfiles(c, s.db, s.hydrator)
-	})
+	}, s.optionalAuth)
 	xrpcGroup.GET("/app.bsky.actor.getPreferences", func(c echo.Context) error {
 		return actor.HandleGetPreferences(c, s.db, s.hydrator)
 	}, s.requireAuth)
···
 	}, s.requireAuth)
 	xrpcGroup.GET("/app.bsky.feed.getFeed", func(c echo.Context) error {
 		return feed.HandleGetFeed(c, s.db, s.hydrator, s.dir)
-	})
+	}, s.optionalAuth)
 	xrpcGroup.GET("/app.bsky.feed.getFeedGenerator", func(c echo.Context) error {
 		return feed.HandleGetFeedGenerator(c, s.db, s.hydrator, s.dir)
 	})