iter.Seqを非同期解決して普通のRESTfulでもdataloaderが使えるようにできないか

type Nexter interface {
	Next() bool
}

rows, err := db.QueryxContext(
    ctx,
    "SELECT `id`, `user_id`, `body`, `mime`, `created_at` FROM `posts` ORDER BY `created_at` DESC",
)
if err != nil 
    return fmt.Errorf("failed to query posts: %w", err)
}
postsIter := iterutils.FromNexter2(rows, func(rows *sqlx.Rows) (*Post, error) {
    var p Post
    if err := rows.StructScan(&p); err != nil {
        return nil, fmt.Errorf("failed to scan post: %w", err)
    }
    return &p, nil
})

asyncIter := async.Map2(postsIter, func(p *Post, err error) (*Post, error) {
    mp, err := makePost(p, getCSRFToken(r), false)
    if err != nil {
        return nil, err
    }
    return mp, nil
})

func makePosts(results []Post, csrfToken string, allComments bool) ([]Post, error) {
	var posts []Post

	for _, p := range results {
		_p, err := makePost(&p, csrfToken, allComments)
		if err != nil {
			return nil, err
		}

		if _p.User.DelFlg == 0 {
			posts = append(posts, p)
		}
		if len(posts) >= postsPerPage {
			break
		}
	}

	return posts, nil
}

func makePost(p *Post, csrfToken string, allComments bool) (*Post, error) {
	if err := db.Get(&p.CommentCount, "SELECT COUNT(*) AS `count` FROM `comments` WHERE `post_id` = ?", p.ID); err != nil {
		return nil, err
	}

	query := "SELECT * FROM `comments` WHERE `post_id` = ? ORDER BY `created_at` DESC"
	if !allComments {
		query += " LIMIT 3"
	}
	var comments []Comment
	if err := db.Select(&comments, query, p.ID); err != nil {
		return nil, err
	}

	for i := 0; i < len(comments); i++ {
		err := db.Get(&comments[i].User, "SELECT * FROM `users` WHERE `id` = ?", comments[i].UserID)
		if err != nil {
			return nil, err
		}
	}

	// reverse
	for i, j := 0, len(comments)-1; i < j; i, j = i+1, j-1 {
		comments[i], comments[j] = comments[j], comments[i]
	}

	p.Comments = comments

	if err := db.Get(&p.User, "SELECT * FROM `users` WHERE `id` = ?", p.UserID); err != nil {
		return nil, err
	}

	p.CSRFToken = csrfToken
	return p, nil
}

type dataloaders struct {
	commentCountByPostID   *dataloadgen.Loader[int, int]
	allCommentsByPostID    *dataloadgen.Loader[int, []Comment]
	latestCommentsByPostID *dataloadgen.Loader[int, []Comment]
	userByID               *dataloadgen.Loader[int, User]
}

func newDataloaders() *dataloaders {
	return &dataloaders{
		commentCountByPostID: dataloadgen.NewLoader(
			func(ctx context.Context, keys []int) ([]int, []error) {
				query := "SELECT `post_id`, COUNT(*) AS `count` FROM `comments` WHERE `post_id` IN (?) GROUP BY `post_id`"
				query, args, err := sqlx.In(query, keys)
				if err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				type postCommentCount struct {
					PostID int `db:"post_id"`
					Count  int `db:"count"`
				}
				var results []postCommentCount
				if err := db.SelectContext(ctx, &results, query, args...); err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				m := make(map[int]int, len(results))
				for _, r := range results {
					m[r.PostID] = r.Count
				}
				mm := it.Map(slices.Values(keys), func(k int) int {
					return m[k]
				})
				counts := slices.Collect(mm)
				return counts, nil
			}),
		allCommentsByPostID: dataloadgen.NewLoader(
			func(ctx context.Context, keys []int) ([][]Comment, []error) {
				query := "SELECT * FROM `comments` WHERE `post_id` IN (?) ORDER BY `created_at` DESC"
				query, args, err := sqlx.In(query, keys)
				if err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				var results []Comment
				if err := db.SelectContext(ctx, &results, query, args...); err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				m := make(map[int][]Comment, len(keys))
				for _, r := range results {
					m[r.PostID] = append(m[r.PostID], r)
				}
				mm := it.Map(slices.Values(keys), func(k int) []Comment {
					return m[k]
				})
				comments := slices.Collect(mm)
				return comments, nil
			},
		),
		latestCommentsByPostID: dataloadgen.NewLoader(
			func(ctx context.Context, keys []int) ([][]Comment, []error) {
				query := `
SELECT c.id, c.post_id, c.user_id, c.comment, c.created_at
FROM (
    SELECT id, post_id, user_id, comment, created_at,
           ROW_NUMBER() OVER (PARTITION BY post_id ORDER BY created_at DESC) as rn
    FROM comments
    WHERE post_id IN (?)
) c
WHERE c.rn <= 3
ORDER BY c.post_id, c.created_at DESC;`
				query, args, err := sqlx.In(query, keys)
				if err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				var results []Comment
				if err := db.SelectContext(ctx, &results, query, args...); err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				m := make(map[int][]Comment, len(keys))
				for _, r := range results {
					m[r.PostID] = append(m[r.PostID], r)
				}
				mm := it.Map(slices.Values(keys), func(k int) []Comment {
					return m[k]
				})
				comments := slices.Collect(mm)
				return comments, nil
			},
		),
		userByID: dataloadgen.NewLoader(
			func(ctx context.Context, keys []int) ([]User, []error) {
				query := "SELECT * FROM `users` WHERE `id` IN (?)"
				query, args, err := sqlx.In(query, keys)
				if err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				var results []User
				if err := db.SelectContext(ctx, &results, query, args...); err != nil {
					errs := slices.Repeat([]error{err}, len(keys))
					return nil, errs
				}
				m := make(map[int]User, len(results))
				for _, r := range results {
					m[r.ID] = r
				}
				mm := it.Map(slices.Values(keys), func(k int) User {
					return m[k]
				})
				users := slices.Collect(mm)
				return users, nil
			},
		),
	}
}

func makePostDL(ctx context.Context, p *Post, csrfToken string, allComments bool, dl *dataloaders) (*Post, error) {
	eg := errgroup.Group{}
	eg.Go(func() error {
		count, err := dl.commentCountByPostID.Load(ctx, p.ID)
		if err != nil {
			return err
		}
		p.CommentCount = count
		return nil
	})
	eg.Go(func() error {
		var comments []Comment
		if allComments {
			_comments, err := dl.allCommentsByPostID.Load(ctx, p.ID)
			if err != nil {
				return err
			}
			comments = _comments
		} else {
			_comments, err := dl.latestCommentsByPostID.Load(ctx, p.ID)
			if err != nil {
				return err
			}
			comments = _comments
		}

		cwuiter := async.Map2(slices.All(comments), func(_ int, c Comment) (*Comment, error) {
			user, err := dl.userByID.Load(ctx, c.UserID)
			if err != nil {
				return nil, err
			}
			c.User = user
			return &c, nil
		})
		cwus, err := it.TryCollect(cwuiter)
		if err != nil {
			return err
		}
		slices.Reverse(cwus)
		derefIter := it.Map(slices.Values(cwus), func(c *Comment) Comment {
			return *c
		})

		p.Comments = slices.Collect(derefIter)
		return nil
	})

	eg.Go(func() error {
		u, err := dl.userByID.Load(ctx, p.UserID)
		if err != nil {
			return err
		}
		p.User = u
		return nil
	})
	if err := eg.Wait(); err != nil {
		return nil, err
	}

	p.CSRFToken = csrfToken
	return p, nil
}

func getIndex2(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	me := getSessionUser(r)
	dl := newDataloaders()

	rows, err := db.QueryxContext(
		ctx,
		"SELECT posts.id, posts.user_id, posts.body, posts.mime, posts.created_at FROM posts INNER JOIN users ON posts.user_id = users.id WHERE users.del_flg = 0 ORDER BY posts.created_at DESC LIMIT ?",
		postsPerPage,
	)
	if err != nil {
		log.Print(err)
		return
	}
	postsIter := iterutils.FromNexter2(rows, func(rows *sqlx.Rows) (*Post, error) {
		var p Post
		if err := rows.StructScan(&p); err != nil {
			return nil, err
		}
		return &p, nil
	})
	asyncIter := async.Map2(postsIter, func(p *Post, err error) (*Post, error) {
		mp, err := makePostDL(ctx, p, getCSRFToken(r), false, dl)
		if err != nil {
			return nil, err
		}
		return mp, nil
	})
	var posts []Post
	for p, err := range asyncIter {
		if err != nil {
			log.Print(err)
			return
		}
		posts = append(posts, *p)
	}

	fmap := template.FuncMap{
		"imageURL": imageURL,
	}

	template.Must(template.New("layout.html").Funcs(fmap).ParseFiles(
		getTemplPath("layout.html"),
		getTemplPath("index.html"),
		getTemplPath("posts.html"),
		getTemplPath("post.html"),
	)).Execute(w, struct {
		Posts     []Post
		Me        User
		CSRFToken string
		Flash     string
	}{posts, me, getCSRFToken(r), getFlash(w, r, "notice")})
}