more endpoints

api/server/feedgetlikes.go

···
 	"github.com/labstack/echo/v4"
 	vyletdatabase "github.com/vylet-app/go/database/proto"
 	"github.com/vylet-app/go/generated/vylet"
+	"github.com/vylet-app/go/internal/helpers"
 )
 
 type GetFeedLikesBySubjectInput struct {
 	Uri    string  `query:"uri"`
-	Limit  int64   `query:"limit"`
+	Limit  *int64  `query:"limit"`
 	Cursor *string `query:"cursor"`
 }
 
-func (s *Server) getLikesBySubject(ctx context.Context, subjectUri string, limit int64, cursor *string) ([]*vylet.FeedGetSubjectLikes_Like, error) {
+func (s *Server) getLikesBySubject(ctx context.Context, subjectUri string, limit int64, cursor *string) ([]*vylet.FeedGetSubjectLikes_Like, *string, error) {
 	logger := s.logger.With("name", "getLikesBySubject", "uri", subjectUri)
 
 	resp, err := s.client.Like.GetLikesBySubject(ctx, &vyletdatabase.GetLikesBySubjectRequest{
···
 		Cursor:     cursor,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("failed to get likes by subject: %w", err)
+		return nil, nil, fmt.Errorf("failed to get likes by subject: %w", err)
 	}
 
 	dids := make([]string, 0, len(resp.Likes))
···
 
 	profiles, err := s.getProfiles(ctx, dids)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get profiles for subject: %w", err)
+		return nil, nil, fmt.Errorf("failed to get profiles for subject: %w", err)
 	}
 
 	likes := make([]*vylet.FeedGetSubjectLikes_Like, 0, len(resp.Likes))
···
 		})
 	}
 
-	return likes, nil
+	return likes, resp.Cursor, nil
 }
 
-func (s *Server) handleGetLikesBySubject(e echo.Context) error {
+func (s *Server) handleGetSubjectLikes(e echo.Context) error {
 	ctx := e.Request().Context()
 
-	logger := s.logger.With("name", "handleGetLikesByPost")
+	logger := s.logger.With("name", "handleGetSubjectLikes")
 
 	var input GetFeedLikesBySubjectInput
 	if err := e.Bind(&input); err != nil {
···
 		return NewValidationError("uri", "URI must be provided")
 	}
 
-	if input.Limit < 1 || input.Limit > 100 {
+	if input.Limit != nil && (*input.Limit < 1 || *input.Limit > 100) {
 		return NewValidationError("limit", "limit must be between 1 and 100")
+	} else if input.Limit == nil {
+		input.Limit = helpers.ToInt64Ptr(25)
 	}
 
 	logger = logger.With("uri", input.Uri)
 
-	likes, err := s.getLikesBySubject(ctx, input.Uri, input.Limit, input.Cursor)
+	likes, cursor, err := s.getLikesBySubject(ctx, input.Uri, *input.Limit, input.Cursor)
 	if err != nil {
 		logger.Error("failed to get subject likes", "err", err)
 		return ErrInternalServerErr
 	}
 
 	return e.JSON(200, vylet.FeedGetSubjectLikes_Output{
-		Likes: likes,
+		Likes:  likes,
+		Cursor: cursor,
 	})
 }

api/server/feedgetposts.go

···
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"sort"
 	"time"
 
 	"github.com/bluesky-social/indigo/lex/util"
···
 	"github.com/vylet-app/go/internal/helpers"
 	"golang.org/x/sync/errgroup"
 )
-
-type GetFeedPostsInput struct {
-	Uris []string `query:"uris"`
-}
 
 func (s *Server) getPosts(ctx context.Context, uris []string) (map[string]*vylet.FeedPost, error) {
 	resp, err := s.client.Post.GetPosts(ctx, &vyletdatabase.GetPostsRequest{
···
 }
 
 func (s *Server) getPostViews(ctx context.Context, uris []string, viewer string) (map[string]*vylet.FeedDefs_PostView, error) {
-	logger := s.logger.With("name", "feedPostsToPostViews")
-
 	resp, err := s.client.Post.GetPosts(ctx, &vyletdatabase.GetPostsRequest{
 		Uris: uris,
 	})
···
 		return nil, ErrDatabaseNotFound
 	}
 
-	dids := make([]string, 0, len(resp.Posts))
+	feedPostViews, err := s.postsToPostViews(ctx, resp.Posts, viewer)
+	if err != nil {
+		return nil, err
+	}
+
+	return feedPostViews, nil
+}
+
+func (s *Server) postsToPostViews(ctx context.Context, posts map[string]*vyletdatabase.Post, viewer string) (map[string]*vylet.FeedDefs_PostView, error) {
+	logger := s.logger.With("name", "postsToPostViews")
+
+	uris := make([]string, 0, len(posts))
+	dids := make([]string, 0, len(posts))
 	addedDids := make(map[string]struct{})
-	for _, post := range resp.Posts {
+	for uri, post := range posts {
+		uris = append(uris, uri)
+
 		if _, ok := addedDids[post.AuthorDid]; ok {
 			continue
 		}
···
 	}
 
 	feedPostViews := make(map[string]*vylet.FeedDefs_PostView)
-	for _, post := range resp.Posts {
+	for _, post := range posts {
 		profileBasic, ok := profiles[post.AuthorDid]
 		if !ok {
 			logger.Warn("failed to get profile for post", "did", post.AuthorDid, "uri", post.Uri)
···
 	return feedPostViews, nil
 }
 
+type GetFeedPostsInput struct {
+	Uris []string `query:"uris"`
+}
+
 func (s *Server) handleGetPosts(e echo.Context) error {
 	ctx := e.Request().Context()
 
···
 		Posts: orderedPostViews,
 	})
 }
+
+type GetFeedActorPostsInput struct {
+	Actor  string  `query:"actor"`
+	Limit  *int64  `query:"limit"`
+	Cursor *string `query:"cursor"`
+}
+
+func (s *Server) handleGetActorPosts(e echo.Context) error {
+	ctx := e.Request().Context()
+
+	logger := s.logger.With("name", "handleGetActorPosts")
+
+	var input GetFeedActorPostsInput
+	if err := e.Bind(&input); err != nil {
+		logger.Error("failed to bind", "err", err)
+		return ErrInternalServerErr
+	}
+
+	if input.Limit != nil && (*input.Limit < 1 || *input.Limit > 100) {
+		return NewValidationError("limit", "limit must be between 1 and 100")
+	} else if input.Limit == nil {
+		input.Limit = helpers.ToInt64Ptr(25)
+	}
+
+	logger = logger.With("actor", input.Actor, "limit", *input.Limit, "cursor", input.Cursor)
+
+	did, _, err := s.fetchDidHandleFromActor(ctx, input.Actor)
+	if err != nil {
+		if errors.Is(err, ErrActorNotValid) {
+			return NewValidationError("actor", "actor must be a valid DID or handle")
+		}
+		logger.Error("error fetching did and handle", "err", err)
+		return ErrInternalServerErr
+	}
+
+	resp, err := s.client.Post.GetPostsByActor(ctx, &vyletdatabase.GetPostsByActorRequest{
+		Did:    did,
+		Limit:  *input.Limit,
+		Cursor: input.Cursor,
+	})
+	if err != nil {
+		logger.Error("failed to get posts", "did", did)
+		return ErrInternalServerErr
+	}
+
+	postViews, err := s.postsToPostViews(ctx, resp.Posts, "") // TODO: set viewer
+	if err != nil {
+		s.logger.Error("failed to get post views", "err", err)
+		return ErrInternalServerErr
+	}
+
+	sortedPostViews := make([]*vylet.FeedDefs_PostView, 0, len(postViews))
+	for _, postView := range postViews {
+		sortedPostViews = append(sortedPostViews, postView)
+	}
+	sort.Slice(sortedPostViews, func(i, j int) bool {
+		return sortedPostViews[i].CreatedAt > sortedPostViews[j].CreatedAt
+	})
+
+	return e.JSON(200, vylet.FeedGetActorPosts_Output{
+		Posts:  sortedPostViews,
+		Cursor: resp.Cursor,
+	})
+}

api/server/server.go

···
 
 	// app.vylet.feed
 	s.echo.GET("/xrpc/app.vylet.feed.getPosts", s.handleGetPosts)
-	s.echo.GET("/xrpc/app.vylet.feed.getSubjectLikes", s.handleGetLikesBySubject)
+	s.echo.GET("/xrpc/app.vylet.feed.getSubjectLikes", s.handleGetSubjectLikes)
+	s.echo.GET("/xrpc/app.vylet.feed.getActorPosts", s.handleGetActorPosts)
 }
 
 func (s *Server) errorHandler(err error, c echo.Context) {

bench.py

···
+import requests
+import time
+import sys
+from datetime import datetime
+
+# Configuration
+URL = "http://localhost:8080/xrpc/app.vylet.feed.getActorPosts?actor=hailey.at"
+INITIAL_DELAY = 5.0
+MIN_DELAY = 0.001
+RAMP_FACTOR = 0.5
+
+
+def make_request(session, request_num, delay):
+    try:
+        start_time = time.time()
+        response = session.get(URL, timeout=10)
+        elapsed = time.time() - start_time
+
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        rate = 1 / delay if delay > 0 else float("inf")
+
+        print(
+            f"[{timestamp}] Request #{request_num:4d} | "
+            f"Status: {response.status_code} | "
+            f"Time: {elapsed:.3f}s | "
+            f"Rate: {rate:.2f} req/s"
+        )
+
+        return True
+    except requests.exceptions.RequestException as e:
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        print(f"[{timestamp}] Request #{request_num:4d} | ERROR: {e}")
+        return False
+
+
+def main():
+    print("=" * 70)
+    print("Gradual Load Tester")
+    print("=" * 70)
+    print(f"Target URL: {URL}")
+    print(f"Starting delay: {INITIAL_DELAY}s ({1 / INITIAL_DELAY:.2f} req/s)")
+    print(f"Min delay: {MIN_DELAY}s ({1 / MIN_DELAY:.2f} req/s)")
+    print(
+        f"Ramp factor: {RAMP_FACTOR} (gets {(1 - RAMP_FACTOR) * 100:.0f}% faster each cycle)"
+    )
+    print("=" * 70)
+    print("\nPress Ctrl+C to stop\n")
+
+    session = requests.Session()
+    delay = INITIAL_DELAY
+    request_num = 0
+
+    try:
+        while True:
+            request_num += 1
+            make_request(session, request_num, delay)
+
+            time.sleep(delay)
+
+            if delay > MIN_DELAY:
+                delay = max(delay * RAMP_FACTOR, MIN_DELAY)
+                if delay == MIN_DELAY:
+                    print(f"\n{'=' * 70}")
+                    print(f"Reached maximum rate: {1 / MIN_DELAY:.2f} requests/second")
+                    print(f"{'=' * 70}\n")
+
+    except KeyboardInterrupt:
+        print(f"\n\n{'=' * 70}")
+        print(f"Stopped after {request_num} requests")
+        print(f"Final rate: {1 / delay:.2f} requests/second")
+        print(f"{'=' * 70}")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

generated/vylet/feedgetActorPosts.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+// Lexicon schema: app.vylet.feed.getActorPosts
+
+package vylet
+
+import (
+	"context"
+
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+)
+
+// FeedGetActorPosts_Output is the output of a app.vylet.feed.getActorPosts call.
+type FeedGetActorPosts_Output struct {
+	Cursor *string              `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	Posts  []*FeedDefs_PostView `json:"posts" cborgen:"posts"`
+}
+
+// FeedGetActorPosts calls the XRPC method "app.vylet.feed.getActorPosts".
+func FeedGetActorPosts(ctx context.Context, c lexutil.LexClient, actor string, cursor string, limit int64) (*FeedGetActorPosts_Output, error) {
+	var out FeedGetActorPosts_Output
+
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if err := c.LexDo(ctx, lexutil.Query, "", "app.vylet.feed.getActorPosts", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

internal/helpers/helpers.go

···
 	return &str
 }
 
+func ToIntPtr(num int) *int {
+	return &num
+}
+
+func ToInt64Ptr(num int64) *int64 {
+	return &num
+}
+
 func ImageCidToCdnUrl(cid string, size string) string {
 	return fmt.Sprintf("https://cdn.vylet.app/%s/%s@png", cid, size)
 }