Итоговый проект: микроблог

type User struct{ ent.Schema }

func (User) Fields() []ent.Field {
        return []ent.Field{
                field.String("name").NotEmpty(),
                field.Int("age").Positive(),
                field.String("email").Unique(),
                field.Int("posts_count").Default(0),
                field.Time("deleted_at").Optional().Nillable(),
        }
}

func (User) Edges() []ent.Edge {
        return []ent.Edge{
                edge.To("posts", Post.Type),
                edge.To("comments", Comment.Type),
                edge.To("likes", Like.Type),
                edge.To("friends", User.Type),
                edge.To("following", User.Type).From("followers"),
        }
}

type Post struct{ ent.Schema }

func (Post) Fields() []ent.Field {
        return []ent.Field{
                field.String("title").NotEmpty(),
                field.Text("body"),
                field.Time("created_at").Default(time.Now),
                field.Time("deleted_at").Optional().Nillable(),
        }
}

func (Post) Edges() []ent.Edge {
        return []ent.Edge{
                edge.From("author", User.Type).Ref("posts").
                        Field("author_id").Required().Unique(),
                edge.To("comments", Comment.Type),
                edge.To("likes", Like.Type),
        }
}

func (Post) Indexes() []ent.Index {
        return []ent.Index{
                index.Edges("author").Fields("created_at").
                        Annotations(entsql.Desc(), entsql.IndexWhere("deleted_at IS NULL")).
                        StorageKey("posts_author_created_idx"),
        }
}

type Comment struct{ ent.Schema }

func (Comment) Fields() []ent.Field {
        return []ent.Field{
                field.Text("body").NotEmpty(),
                field.Time("created_at").Default(time.Now),
        }
}

func (Comment) Edges() []ent.Edge {
        return []ent.Edge{
                edge.From("post", Post.Type).Ref("comments").
                        Field("post_id").Required().Unique(),
                edge.From("author", User.Type).Ref("comments").
                        Field("author_id").Required().Unique(),
        }
}

type Like struct{ ent.Schema }

func (Like) Edges() []ent.Edge {
        return []ent.Edge{
                edge.From("post", Post.Type).Ref("likes").
                        Field("post_id").Required().Unique(),
                edge.From("user", User.Type).Ref("likes").
                        Field("user_id").Required().Unique(),
        }
}

func (Like) Indexes() []ent.Index {
        return []ent.Index{
                index.Edges("post", "user").Unique().
                        StorageKey("likes_post_user_uq"),
        }
}

type BlogService struct{ client *ent.Client }

func NewBlogService(c *ent.Client) *BlogService {
        return &BlogService{client: c}
}

func (s *BlogService) CreateAuthor(ctx context.Context, name, email string, age int) (*ent.User, error) {
        u, err := s.client.User.Create().
                SetName(name).SetEmail(email).SetAge(age).
                Save(ctx)
        if ent.IsConstraintError(err) {
                return nil, ErrEmailTaken // доменная ошибка: наверху -> 409
        }
        return u, err
}

func (s *BlogService) Publish(ctx context.Context, authorID int, title, body string) (*ent.Post, error) {
        var post *ent.Post
        err := WithTx(ctx, s.client, func(tx *ent.Tx) error {
                var err error
                post, err = tx.Post.Create().
                        SetTitle(title).SetBody(body).
                        SetAuthorID(authorID).
                        Save(ctx)
                return err // хук 17-го сдвинет posts_count в этой же транзакции
        })
        return post, err
}

func (s *BlogService) ToggleLike(ctx context.Context, userID, postID int) (bool, error) {
        err := s.client.Like.Create().
                SetUserID(userID).SetPostID(postID).
                Save(ctx)
        switch {
        case err == nil:
                return true, nil // поставили лайк
        case ent.IsConstraintError(err):
                _, err := s.client.Like.Delete().
                        Where(like.UserIDEQ(userID), like.PostIDEQ(postID)).
                        Exec(ctx)
                return false, err // сняли лайк
        default:
                return false, err // настоящая ошибка базы — наверх
        }
}

st1, err1 := svc.ToggleLike(ctx, anna.ID, post.ID)
st2, err2 := svc.ToggleLike(ctx, anna.ID, post.ID)
n, _ := svc.LikeCount(ctx, post.ID)

fmt.Println(st1, err1 == nil, st2, err2 == nil, n)

// type Cursor struct { Time time.Time; ID int }

func (s *BlogService) Feed(ctx context.Context, me int, cur *Cursor) ([]*ent.Post, error) {
        q := s.client.Post.Query().
                Where(post.HasAuthorWith(user.HasFollowersWith(user.IDEQ(me)))).
                WithAuthor(func(aq *ent.UserQuery) {
                        aq.Select(user.FieldName, user.FieldPostsCount)
                }).
                WithComments(func(cq *ent.CommentQuery) {
                        cq.Order(ent.Desc(comment.FieldCreatedAt)).Limit(3).
                                WithAuthor(func(aq *ent.UserQuery) {
                                        aq.Select(user.FieldName)
                                })
                }).
                Order(ent.Desc(post.FieldCreatedAt), ent.Asc(post.FieldID)).
                Limit(20)
        if cur != nil {
                q = q.Where(post.CreatedAtLT(cur.Time), post.IDGT(cur.ID))
        }
        return q.All(ctx)
}

func main() {
        ctx := context.Background()
        dsn := os.Getenv("BLOG_DSN")
        if dsn == "" {
                log.Fatal("BLOG_DSN пуст: старт невозможен")
        }

        db, err := sql.Open(dialect.Postgres, dsn)
        if err != nil {
                log.Fatal(err)
        }
        db.SetMaxOpenConns(25)
        db.SetConnMaxLifetime(30 * time.Minute)

        client := ent.NewClient(ent.Driver(entsql.OpenDB(dialect.Postgres, db)))
        if err := client.Schema.Create(ctx); err != nil {
                log.Fatal(err)
        }
        svc := NewBlogService(client)

        mux := http.NewServeMux()
        mux.HandleFunc("POST /authors", handleCreateAuthor(svc))
        mux.HandleFunc("POST /posts", handlePublish(svc))
        mux.HandleFunc("POST /posts/{id}/like", handleToggleLike(svc))
        mux.HandleFunc("GET /feed", handleFeed(svc))

        log.Println("блог на ent слушает :8080")
        log.Fatal(http.ListenAndServe(":8080", mux))
}

func TestFeedFollowsOnly(t *testing.T) {
        client := enttest.Open(t, dialect.SQLite,
                fmt.Sprintf("file:test_%s?mode=memory&_fk=1", t.Name()))
        defer client.Close()

        svc := NewBlogService(client)
        users := seedMicroblog(t, client) // анна, борис, вера + подписки

        page, err := svc.Feed(ctx, users.anna.ID, nil)
        if err != nil {
                t.Fatal(err)
        }
        if len(page) == 0 {
                t.Fatal("лента анны пуста: подписка на бориса потерялась")
        }
        for _, p := range page {
                if p.Edges.Author.Name == "вера" {
                        t.Fatal("пост веры не должен попадать в ленту анны")
                }
        }
}