Fixed ordering of published posts

providers/db/categories.go

@@ -82,7 +82,7 @@ func (db *Provider) SelectCategoriesOfPost(ctx context.Context, postID int64) ([
 	return cats, nil
 }
 
-func (db *Provider) SelectPostsOfCategory(ctx context.Context, categoryID int64, pp PagingParams) ([]*models.Post, error) {
+func (db *Provider) SelectPublishedPostsOfCategory(ctx context.Context, categoryID int64, pp PagingParams) ([]*models.Post, error) {
 	rows, err := db.queries.SelectPostsOfCategory(ctx, sqlgen.SelectPostsOfCategoryParams{
 		CategoryID: categoryID,
 		Limit:      pp.Limit,

providers/db/gen/sqlgen/categories.sql.go

@@ -227,7 +227,7 @@ func (q *Queries) SelectCategoryBySlugAndSite(ctx context.Context, arg SelectCat
 	return i, err
 }
 
-const selectPostsOfCategory = `-- name: SelectPostsOfCategory :many
+const selectPublishedPostsOfCategory = `-- name: SelectPublishedPostsOfCategory :many
 SELECT p.id, p.site_id, p.state, p.guid, p.title, p.body, p.slug, p.created_at, p.updated_at, p.published_at, p.deleted_at FROM posts p
 INNER JOIN post_categories pc ON pc.post_id = p.id
 WHERE pc.category_id = ? AND p.state = 0 AND p.deleted_at = 0
@@ -235,14 +235,14 @@ ORDER BY p.published_at DESC
 LIMIT ? OFFSET ?
 `
 
-type SelectPostsOfCategoryParams struct {
+type SelectPublishedPostsOfCategoryParams struct {
 	CategoryID int64
 	Limit      int64
 	Offset     int64
 }
 
-func (q *Queries) SelectPostsOfCategory(ctx context.Context, arg SelectPostsOfCategoryParams) ([]Post, error) {
+func (q *Queries) SelectPublishedPostsOfCategory(ctx context.Context, arg SelectPublishedPostsOfCategoryParams) ([]Post, error) {
-	rows, err := q.db.QueryContext(ctx, selectPostsOfCategory, arg.CategoryID, arg.Limit, arg.Offset)
+	rows, err := q.db.QueryContext(ctx, selectPublishedPostsOfCategory, arg.CategoryID, arg.Limit, arg.Offset)
 	if err != nil {
 		return nil, err
 	}

providers/db/gen/sqlgen/posts.sql.go

@@ -200,6 +200,54 @@ func (q *Queries) SelectPostsOfSite(ctx context.Context, arg SelectPostsOfSitePa
 	return items, nil
 }
 
+const selectPublishedPostsOfSite = `-- name: SelectPublishedPostsOfSite :many
+SELECT id, site_id, state, guid, title, body, slug, created_at, updated_at, published_at, deleted_at
+FROM posts
+WHERE site_id = ?1 AND state = 0 AND deleted_at = 0
+ORDER BY published_at DESC LIMIT ?3 OFFSET ?2
+`
+
+type SelectPublishedPostsOfSiteParams struct {
+	SiteID int64
+	Offset int64
+	Limit  int64
+}
+
+func (q *Queries) SelectPublishedPostsOfSite(ctx context.Context, arg SelectPublishedPostsOfSiteParams) ([]Post, error) {
+	rows, err := q.db.QueryContext(ctx, selectPublishedPostsOfSite, arg.SiteID, arg.Offset, arg.Limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items []Post
+	for rows.Next() {
+		var i Post
+		if err := rows.Scan(
+			&i.ID,
+			&i.SiteID,
+			&i.State,
+			&i.Guid,
+			&i.Title,
+			&i.Body,
+			&i.Slug,
+			&i.CreatedAt,
+			&i.UpdatedAt,
+			&i.PublishedAt,
+			&i.DeletedAt,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 const softDeletePost = `-- name: SoftDeletePost :exec
 UPDATE posts SET deleted_at = ? WHERE id = ?
 `

providers/db/posts.go

@@ -47,6 +47,23 @@ func (db *Provider) SelectPostsOfSite(ctx context.Context, siteID int64, showDel
 	return posts, nil
 }
 
+func (db *Provider) SelectPublishedPostsOfSite(ctx context.Context, siteID int64, pp PagingParams) ([]*models.Post, error) {
+	rows, err := db.queries.SelectPublishedPostsOfSite(ctx, sqlgen.SelectPublishedPostsOfSiteParams{
+		SiteID: siteID,
+		Limit:  pp.Limit,
+		Offset: pp.Offset,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	posts := make([]*models.Post, len(rows))
+	for i, row := range rows {
+		posts[i] = dbPostToPost(row)
+	}
+	return posts, nil
+}
+
 func (db *Provider) SelectPost(ctx context.Context, postID int64) (*models.Post, error) {
 	row, err := db.queries.SelectPost(ctx, postID)
 	if err != nil {

services/publisher/iter.go

@@ -9,10 +9,10 @@ import (
 )
 
 // postIter returns a post iterator which returns posts in reverse chronological order.
-func (s *Publisher) postIter(ctx context.Context, site int64) iter.Seq[models.Maybe[*models.Post]] {
+func (s *Publisher) publishedPostIter(ctx context.Context, site int64) iter.Seq[models.Maybe[*models.Post]] {
 	return func(yield func(models.Maybe[*models.Post]) bool) {
 		paging := db.PagingParams{Offset: 0, Limit: 50}
-		page, err := s.db.SelectPostsOfSite(ctx, site, false, paging)
+		page, err := s.db.SelectPublishedPostsOfSite(ctx, site, paging)
 		if err != nil {
 			yield(models.Maybe[*models.Post]{Err: err})
 			return
@@ -45,7 +45,7 @@ func (s *Publisher) postIterByCategory(ctx context.Context, categoryID int64) it
 	return func(yield func(models.Maybe[*models.Post]) bool) {
 		paging := db.PagingParams{Offset: 0, Limit: 50}
 		for {
-			page, err := s.db.SelectPostsOfCategory(ctx, categoryID, paging)
+			page, err := s.db.SelectPublishedPostsOfCategory(ctx, categoryID, paging)
 			if err != nil {
 				yield(models.Maybe[*models.Post]{Err: err})
 				return

services/publisher/service.go

@@ -79,7 +79,7 @@ func (p *Publisher) Publish(ctx context.Context, site models.Site) error {
 		pubSite := pubmodel.Site{
 			Site: site,
 			PostIter: func(ctx context.Context) iter.Seq[models.Maybe[*models.Post]] {
-				return p.postIter(ctx, site.ID)
+				return p.publishedPostIter(ctx, site.ID)
 			},
 			BaseURL:    target.BaseURL,
 			Uploads:    uploads,

sql/queries/categories.sql

@@ -17,7 +17,7 @@ INNER JOIN post_categories pc ON pc.category_id = c.id
 WHERE pc.post_id = ?
 ORDER BY c.name ASC;
 
--- name: SelectPostsOfCategory :many
+-- name: SelectPublishedPostsOfCategory :many
 SELECT p.* FROM posts p
 INNER JOIN post_categories pc ON pc.post_id = p.id
 WHERE pc.category_id = ? AND p.state = 0 AND p.deleted_at = 0

sql/queries/posts.sql

@@ -17,6 +17,12 @@ WHERE site_id = sqlc.arg(site_id) AND (
     END
 ) ORDER BY created_at DESC LIMIT sqlc.arg(limit) OFFSET sqlc.arg(offset);
 
+-- name: SelectPublishedPostsOfSite :many
+SELECT *
+FROM posts
+WHERE site_id = sqlc.arg(site_id) AND state = 0 AND deleted_at = 0
+ORDER BY published_at DESC LIMIT sqlc.arg(limit) OFFSET sqlc.arg(offset);
+
 -- name: SelectPost :one
 SELECT * FROM posts WHERE id = ? LIMIT 1;