feat(realtime): доставлять клиентам события жизненного цикла альбома и изменения состава фото

Публиковать album.created/updated/deleted и изменения состава фото в личный поток SSE, а также photo.created при загрузке, чтобы списки альбомов, счётчики и открытые страницы альбома обновлялись без перезагрузки. - members.Repository получил Audience (владелец + участники) для дешёвого веера - albums.Service рассылает события в личные потоки получателей, перечитывая альбом через GetByID и attachCover, чтобы payload совпадал с GET /api/albums - members.Service публикует при принятии инвайта, смене роли и исключении - photos.Service публикует photo.created при загрузке и album.updated при добавлении/копировании/перемещении/восстановлении/корзине/окончательном удалении - photos_count теперь считает фото вне корзины - web-клиент подписывается на /api/sse/me один раз на уровне layout'а (app) и применяет события к стору альбомов; страница альбома уходит при потере доступа
2026-10-15 23:25:07 +03:00
parent cbff7a340c
commit e82f45647c
31 changed files with 2157 additions and 28 deletions
@@ -0,0 +1,108 @@
+package members_test
+
+import (
+	"context"
+	"database/sql"
+	"io/fs"
+	"path/filepath"
+	"sort"
+	"testing"
+	"time"
+
+	assets "galo"
+	"galo/internal/albums"
+	"galo/internal/auth"
+	"galo/internal/db"
+	"galo/internal/members"
+	"galo/internal/sse"
+	"galo/internal/store"
+)
+
+type stack struct {
+	db     *sql.DB
+	repos  store.Repos
+	hub    *sse.Hub
+	albums *albums.Service
+	svc    *members.Service
+}
+
+// newStack opens a migrated SQLite database and wires the albums and members
+// services over the real repositories, mirroring the production wiring.
+func newStack(t *testing.T) *stack {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "meta.db")
+	migFS, err := fs.Sub(assets.Migrations, "migrations/sqlite")
+	if err != nil {
+		t.Fatalf("migrations fs: %v", err)
+	}
+	if err := db.MigrateSQLite(path, migFS); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	database, err := db.OpenSQLite(path)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	t.Cleanup(func() { database.Close() })
+
+	repos := store.NewSQLite(database)
+	hub := sse.NewHub(16)
+	albumsSvc := albums.NewService(repos.Albums, repos.Members, hub, nil)
+	membersSvc := members.NewService(repos.Members, albumsSvc, hub, nil)
+	return &stack{db: database, repos: repos, hub: hub, albums: albumsSvc, svc: membersSvc}
+}
+
+func seedUser(t *testing.T, st *stack, name string) string {
+	t.Helper()
+	id := auth.NewID()
+	if _, err := st.db.Exec(
+		`INSERT INTO users (id, email, password_hash, name) VALUES ($1, $2, 'x', $3)`,
+		id, id[:8]+"@test.local", name); err != nil {
+		t.Fatalf("seed user: %v", err)
+	}
+	return id
+}
+
+func nextEvent(t *testing.T, sub *sse.Subscription) sse.Event {
+	t.Helper()
+	select {
+	case ev, ok := <-sub.Events():
+		if !ok {
+			t.Fatal("subscription closed before an event arrived")
+		}
+		return ev
+	case <-time.After(2 * time.Second):
+		t.Fatal("timed out waiting for an event")
+	}
+	return sse.Event{}
+}
+
+func assertNoEvent(t *testing.T, sub *sse.Subscription) {
+	t.Helper()
+	select {
+	case ev, ok := <-sub.Events():
+		if !ok {
+			return
+		}
+		t.Fatalf("unexpected event %q", ev.Type)
+	case <-time.After(50 * time.Millisecond):
+	}
+}
+
+func assertAudience(t *testing.T, st *stack, albumID string, want ...string) {
+	t.Helper()
+	got, err := st.repos.Members.Audience(context.Background(), albumID)
+	if err != nil {
+		t.Fatalf("audience: %v", err)
+	}
+	sort.Strings(got)
+	sorted := append([]string(nil), want...)
+	sort.Strings(sorted)
+	if len(got) != len(sorted) {
+		t.Fatalf("audience = %v, want %v", got, sorted)
+	}
+	for i := range got {
+		if got[i] != sorted[i] {
+			t.Fatalf("audience = %v, want %v", got, sorted)
+		}
+	}
+}
@@ -10,6 +10,10 @@ import (
 type Repository interface {
 	Role(ctx context.Context, albumID, userID string) (string, error)
 	List(ctx context.Context, albumID string) ([]models.AlbumMember, error)
+	// Audience returns the ids of every user the album is visible to: the owner
+	// plus all members. It resolves the set without joining users, so it stays
+	// cheap enough to call for every published album event.
+	Audience(ctx context.Context, albumID string) ([]string, error)
 	Add(ctx context.Context, albumID, userID, role string, invitedBy *string) error
 	UpdateRole(ctx context.Context, albumID, userID, role string) error
 	Remove(ctx context.Context, albumID, userID string) error
@@ -0,0 +1,41 @@
+package members_test
+
+import (
+	"context"
+	"testing"
+
+	"galo/internal/auth"
+	"galo/internal/models"
+)
+
+// Audience must resolve the owner plus every member from their own tables, and
+// must be empty for an album that does not exist.
+func TestAudience(t *testing.T) {
+	ctx := context.Background()
+	st := newStack(t)
+	owner := seedUser(t, st, "Owner")
+	first := seedUser(t, st, "First")
+	second := seedUser(t, st, "Second")
+
+	album := &models.Album{ID: auth.NewID(), OwnerID: owner, Title: "A"}
+	if err := st.repos.Albums.Create(ctx, album); err != nil {
+		t.Fatalf("create album: %v", err)
+	}
+
+	assertAudience(t, st, album.ID, owner)
+
+	if err := st.repos.Members.Add(ctx, album.ID, first, "member", &owner); err != nil {
+		t.Fatalf("add first: %v", err)
+	}
+	if err := st.repos.Members.Add(ctx, album.ID, second, "editor", &owner); err != nil {
+		t.Fatalf("add second: %v", err)
+	}
+	assertAudience(t, st, album.ID, owner, first, second)
+
+	if err := st.repos.Members.Remove(ctx, album.ID, second); err != nil {
+		t.Fatalf("remove second: %v", err)
+	}
+	assertAudience(t, st, album.ID, owner, first)
+
+	assertAudience(t, st, "missing-album")
+}
@@ -12,8 +12,13 @@ import (
 	"galo/internal/sse"
 )

-type AlbumReader interface {
+// AlbumAccess is what the members domain needs from the albums service: the
+// owner of an album for authorization, and the ability to publish an album
+// lifecycle event to specific users' personal streams. It is satisfied by
+// albums.Service.
+type AlbumAccess interface {
 	OwnerID(ctx context.Context, albumID string) (string, error)
+	PublishAlbumTo(ctx context.Context, albumID, eventType string, userIDs []string)
 }

 type Notifier interface {
@@ -22,15 +27,53 @@ type Notifier interface {

 type Service struct {
 	store  Repository
-	albums AlbumReader
+	albums AlbumAccess
 	hub    *sse.Hub
 	notify Notifier
 }

-func NewService(store Repository, albums AlbumReader, hub *sse.Hub, notify Notifier) *Service {
+func NewService(store Repository, albums AlbumAccess, hub *sse.Hub, notify Notifier) *Service {
 	return &Service{store: store, albums: albums, hub: hub, notify: notify}
 }

+// Event names published to personal streams on membership changes. They match
+// the album lifecycle contract published by albums.Service.
+const (
+	eventAlbumCreated = "album.created"
+	eventAlbumUpdated = "album.updated"
+	eventAlbumDeleted = "album.deleted"
+)
+
+// audience returns the users an album is visible to (owner + members), or nil
+// when the lookup fails. A missed fan-out is recovered by the client's
+// reconnect sync, so it must not fail the membership mutation.
+func (s *Service) audience(ctx context.Context, albumID string) []string {
+	if s.albums == nil {
+		return nil
+	}
+	ids, err := s.store.Audience(ctx, albumID)
+	if err != nil {
+		return nil
+	}
+	return ids
+}
+
+// audienceExcept is audience without the given user, used when one recipient
+// must get a different event (the invitee, the removed member).
+func (s *Service) audienceExcept(ctx context.Context, albumID, exclude string) []string {
+	ids := s.audience(ctx, albumID)
+	if exclude == "" {
+		return ids
+	}
+	out := make([]string, 0, len(ids))
+	for _, id := range ids {
+		if id != exclude {
+			out = append(out, id)
+		}
+	}
+	return out
+}
+
 func (s *Service) Role(ctx context.Context, albumID, userID string) (string, error) {
 	return s.store.Role(ctx, albumID, userID)
 }
@@ -113,6 +156,10 @@ func (s *Service) Accept(ctx context.Context, token, userID string) (*models.Inv
 		return nil, err
 	}
 	s.hub.Publish(inv.AlbumID, "member.joined", map[string]string{"album_id": inv.AlbumID, "user_id": userID, "role": inv.Role})
+	// The invitee gains the album and gets its object; everyone already in the
+	// album sees the updated member count.
+	s.albums.PublishAlbumTo(ctx, inv.AlbumID, eventAlbumCreated, []string{userID})
+	s.albums.PublishAlbumTo(ctx, inv.AlbumID, eventAlbumUpdated, s.audienceExcept(ctx, inv.AlbumID, userID))
 	if s.notify != nil {
 		ownerID, err := s.albums.OwnerID(ctx, inv.AlbumID)
 		if err == nil && ownerID != userID {
@@ -168,6 +215,7 @@ func (s *Service) ChangeRole(ctx context.Context, albumID, actorID, targetID, ne
 		return err
 	}
 	s.hub.Publish(albumID, "member.updated", map[string]string{"album_id": albumID, "user_id": targetID, "role": newRole})
+	s.albums.PublishAlbumTo(ctx, albumID, eventAlbumUpdated, s.audience(ctx, albumID))
 	return nil
 }

@@ -196,6 +244,10 @@ func (s *Service) Remove(ctx context.Context, albumID, actorID, targetID string)
 		return err
 	}
 	s.hub.Publish(albumID, "member.left", map[string]string{"album_id": albumID, "user_id": targetID})
+	// Those who remain see the updated member count; the removed member only
+	// learns that the album is gone (album.deleted carries just its id).
+	s.albums.PublishAlbumTo(ctx, albumID, eventAlbumUpdated, s.audience(ctx, albumID))
+	s.albums.PublishAlbumTo(ctx, albumID, eventAlbumDeleted, []string{targetID})
 	return nil
 }

@@ -0,0 +1,141 @@
+package members_test
+
+import (
+	"context"
+	"testing"
+
+	"galo/internal/albums"
+	"galo/internal/members"
+	"galo/internal/models"
+	"galo/internal/sse"
+)
+
+// Accepting an invite gives the invitee album.created with the album object and
+// tells everyone already in the album that the member count changed.
+func TestAcceptInvitePublishesAlbumEvents(t *testing.T) {
+	ctx := context.Background()
+	st := newStack(t)
+	owner := seedUser(t, st, "Owner")
+	invitee := seedUser(t, st, "Invitee")
+
+	album, err := st.albums.Create(ctx, owner, albums.CreateInput{Title: "Trip"})
+	if err != nil {
+		t.Fatalf("create album: %v", err)
+	}
+	inv, err := st.svc.CreateInvite(ctx, album.ID, owner, members.CreateInviteInput{Role: "member", MaxUses: 1})
+	if err != nil {
+		t.Fatalf("create invite: %v", err)
+	}
+
+	inviteeSub := st.hub.SubscribeUser(invitee)
+	defer inviteeSub.Close()
+	ownerSub := st.hub.SubscribeUser(owner)
+	defer ownerSub.Close()
+
+	if _, err := st.svc.Accept(ctx, inv.Token, invitee); err != nil {
+		t.Fatalf("accept: %v", err)
+	}
+
+	ev := nextEvent(t, inviteeSub)
+	if ev.Type != "album.created" {
+		t.Fatalf("invitee event = %q, want album.created", ev.Type)
+	}
+	invitedAlbum, ok := ev.Data.(*models.Album)
+	if !ok || invitedAlbum.ID != album.ID || invitedAlbum.MembersCount != 1 {
+		t.Fatalf("invitee payload = %#v", ev.Data)
+	}
+	assertNoEvent(t, inviteeSub)
+
+	ownerEv := nextEvent(t, ownerSub)
+	if ownerEv.Type != "album.updated" {
+		t.Fatalf("owner event = %q, want album.updated", ownerEv.Type)
+	}
+	ownerAlbum, ok := ownerEv.Data.(*models.Album)
+	if !ok || ownerAlbum.MembersCount != 1 {
+		t.Fatalf("owner payload = %#v", ownerEv.Data)
+	}
+	assertNoEvent(t, ownerSub)
+}
+
+// Changing a member's role notifies the owner, the remaining members and the
+// user whose role changed.
+func TestChangeRolePublishesAlbumUpdated(t *testing.T) {
+	ctx := context.Background()
+	st := newStack(t)
+	owner := seedUser(t, st, "Owner")
+	target := seedUser(t, st, "Target")
+
+	album, err := st.albums.Create(ctx, owner, albums.CreateInput{Title: "Trip"})
+	if err != nil {
+		t.Fatalf("create album: %v", err)
+	}
+	if err := st.repos.Members.Add(ctx, album.ID, target, "member", &owner); err != nil {
+		t.Fatalf("add member: %v", err)
+	}
+
+	ownerSub := st.hub.SubscribeUser(owner)
+	defer ownerSub.Close()
+	targetSub := st.hub.SubscribeUser(target)
+	defer targetSub.Close()
+
+	if err := st.svc.ChangeRole(ctx, album.ID, owner, target, "editor"); err != nil {
+		t.Fatalf("change role: %v", err)
+	}
+
+	for name, sub := range map[string]*sse.Subscription{"owner": ownerSub, "target": targetSub} {
+		ev := nextEvent(t, sub)
+		if ev.Type != "album.updated" {
+			t.Fatalf("%s event = %q, want album.updated", name, ev.Type)
+		}
+		if _, ok := ev.Data.(*models.Album); !ok {
+			t.Fatalf("%s payload type = %T, want *models.Album", name, ev.Data)
+		}
+	}
+}
+
+// Removing a member tells those who remain that the count changed, and sends
+// the removed member album.deleted carrying only the id.
+func TestRemoveMemberPublishesUpdatedAndDeleted(t *testing.T) {
+	ctx := context.Background()
+	st := newStack(t)
+	owner := seedUser(t, st, "Owner")
+	member := seedUser(t, st, "Member")
+
+	album, err := st.albums.Create(ctx, owner, albums.CreateInput{Title: "Trip"})
+	if err != nil {
+		t.Fatalf("create album: %v", err)
+	}
+	if err := st.repos.Members.Add(ctx, album.ID, member, "member", &owner); err != nil {
+		t.Fatalf("add member: %v", err)
+	}
+
+	ownerSub := st.hub.SubscribeUser(owner)
+	defer ownerSub.Close()
+	memberSub := st.hub.SubscribeUser(member)
+	defer memberSub.Close()
+
+	if err := st.svc.Remove(ctx, album.ID, owner, member); err != nil {
+		t.Fatalf("remove: %v", err)
+	}
+
+	ownerEv := nextEvent(t, ownerSub)
+	if ownerEv.Type != "album.updated" {
+		t.Fatalf("owner event = %q, want album.updated", ownerEv.Type)
+	}
+	if a, ok := ownerEv.Data.(*models.Album); !ok || a.MembersCount != 0 {
+		t.Fatalf("owner payload = %#v", ownerEv.Data)
+	}
+
+	memberEv := nextEvent(t, memberSub)
+	if memberEv.Type != "album.deleted" {
+		t.Fatalf("member event = %q, want album.deleted", memberEv.Type)
+	}
+	if _, isAlbum := memberEv.Data.(*models.Album); isAlbum {
+		t.Fatalf("member payload carried an album object")
+	}
+	payload, ok := memberEv.Data.(map[string]string)
+	if !ok || payload["id"] != album.ID {
+		t.Fatalf("member payload = %#v", memberEv.Data)
+	}
+	assertNoEvent(t, memberSub)
+}
@@ -60,6 +60,31 @@ func (s *SQLiteStore) List(ctx context.Context, albumID string) ([]models.AlbumM
 	return out, rows.Err()
 }

+// Audience returns the owner id plus every member id for the album. It reads
+// both from their own tables (no join with users) because the fan-out only
+// needs identifiers.
+func (s *SQLiteStore) Audience(ctx context.Context, albumID string) ([]string, error) {
+	rows, err := s.db.QueryContext(ctx,
+		`SELECT owner_id FROM albums WHERE id = $1
+		 UNION
+		 SELECT user_id FROM album_members WHERE album_id = $1
+		 ORDER BY 1`, albumID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := []string{}
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}
+
 func (s *SQLiteStore) Add(ctx context.Context, albumID, userID, role string, invitedBy *string) error {
 	_, err := s.db.ExecContext(ctx,
 		`INSERT INTO album_members (album_id, user_id, role, invited_by)
@@ -57,6 +57,31 @@ func (s *Store) List(ctx context.Context, albumID string) ([]models.AlbumMember,
 	return out, rows.Err()
 }

+// Audience returns the owner id plus every member id for the album. It reads
+// both from their own tables (no join with users) because the fan-out only
+// needs identifiers.
+func (s *Store) Audience(ctx context.Context, albumID string) ([]string, error) {
+	rows, err := s.pool.Query(ctx,
+		`SELECT owner_id FROM albums WHERE id = $1
+		 UNION
+		 SELECT user_id FROM album_members WHERE album_id = $1
+		 ORDER BY 1`, albumID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	out := []string{}
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}
+
 func (s *Store) Add(ctx context.Context, albumID, userID, role string, invitedBy *string) error {
 	_, err := s.pool.Exec(ctx,
 		`INSERT INTO album_members (album_id, user_id, role, invited_by)