release 1.1.0 : sync V2 (upload, download, purge, placements, rétention, groupes)
Release / release-apk (push) Successful in 9m25s
Release / release-docker (push) Successful in 33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m29s
CI / lint-mobile (push) Failing after 7m46s
CI / test-backend (push) Successful in 1m30s
CI / test-mobile (push) Successful in 9m27s
CI / build-backend (push) Successful in 47s

This commit is contained in:
venture
2026-09-25 20:27:14 +02:00
parent b28fcdc774
commit a34220bf2d
45 changed files with 1900 additions and 76 deletions
+114
View File
@@ -0,0 +1,114 @@
package service
import (
"errors"
"strings"
"github.com/kazier/backend/repository"
)
// GroupDTO serializes a group for GET /groups.
type GroupDTO struct {
ID string `json:"id"`
Name string `json:"name"`
Role string `json:"role"` // "owner" | "member"
}
// sanitizeGroupName trims + caps display names (same spirit as file names).
func sanitizeGroupName(name string) (string, error) {
n := strings.TrimSpace(name)
if n == "" || len(n) > 255 {
return "", ErrInvalidUpload
}
return n, nil
}
// CreateGroup stores a group owned by userID.
func (s *Resources) CreateGroup(userID, name string) (GroupDTO, error) {
clean, err := sanitizeGroupName(name)
if err != nil {
return GroupDTO{}, err
}
id, err := s.Repository.Groups.Create(clean, userID)
if err != nil {
return GroupDTO{}, err
}
return GroupDTO{ID: id, Name: clean, Role: "owner"}, nil
}
// ListGroups returns groups the user owns or joins.
func (s *Resources) ListGroups(userID string) ([]GroupDTO, error) {
groups, err := s.Repository.Groups.ListForUser(userID)
if err != nil {
return nil, err
}
out := make([]GroupDTO, 0, len(groups))
for _, gr := range groups {
out = append(out, GroupDTO{ID: gr.ID, Name: gr.Name, Role: gr.Role})
}
return out, nil
}
// AddGroupMember adds an existing active user to a group the caller owns.
// Unknown group (or not owned) → ErrNotFound (no enumeration) ; unknown
// member → ErrGranteeNotFound (same code as share recipients).
func (s *Resources) AddGroupMember(userID, groupID, memberID string) error {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return err
}
if !owner {
return repository.ErrNotFound
}
if _, err := s.Repository.Users.GetByID(memberID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
return s.Repository.Groups.AddMember(groupID, memberID)
}
// RemoveGroupMember removes a membership (group must be owned by caller).
// Missing membership → ErrNotFound (idempotent-safe callers treat as done).
func (s *Resources) RemoveGroupMember(userID, groupID, memberID string) error {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return err
}
if !owner {
return repository.ErrNotFound
}
return s.Repository.Groups.RemoveMember(groupID, memberID)
}
// MemberDTO serializes a membership for GET /groups/:id/members.
type MemberDTO struct {
ID string `json:"id"`
Username string `json:"username"`
}
// ListMembers returns memberships of a group the caller owns.
func (s *Resources) ListMembers(userID, groupID string) ([]MemberDTO, error) {
owner, err := s.Repository.Groups.IsOwner(groupID, userID)
if err != nil {
return nil, err
}
if !owner {
return nil, repository.ErrNotFound
}
members, err := s.Repository.Groups.ListMembers(groupID)
if err != nil {
return nil, err
}
out := make([]MemberDTO, 0, len(members))
for _, m := range members {
out = append(out, MemberDTO{ID: m.UserID, Username: m.Username})
}
return out, nil
}
// DeleteGroup removes an owned group (member shares cascade via FK).
func (s *Resources) DeleteGroup(userID, groupID string) error {
return s.Repository.Groups.Delete(groupID, userID)
}
+195
View File
@@ -0,0 +1,195 @@
package service
import (
"testing"
"github.com/kazier/backend/repository"
)
// V2-6 : partage vers un groupe — les membres voient la ressource
// (snapshot + enforcement), les non-membres non. Révocation et suppression
// du groupe convergent.
func TestGroupShareSnapshotAndEnforcement(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "grp-owner")
memberID := mustCreateUser(t, s.Repository, "grp-member")
outsiderID := mustCreateUser(t, s.Repository, "grp-outsider")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
groupID, err := s.Repository.Groups.Create("Famille", ownerID)
if err != nil {
t.Fatalf("create group: %v", err)
}
if err := s.Repository.Groups.AddMember(groupID, memberID); err != nil {
t.Fatalf("add member: %v", err)
}
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "g.txt"}),
syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{
"granteeGroupId": groupID,
"access": "editor",
}),
}); err != nil {
t.Fatalf("create+share-group: %v", err)
}
// Snapshot membre : rang editor hérité du groupe.
perms, err := s.Snapshot(memberID, 0)
if err != nil {
t.Fatalf("Snapshot member: %v", err)
}
if len(perms) != 1 || perms[0].EffectiveAccess != "editor" {
t.Fatalf("snapshot membre = %+v, attendu 1 editor", perms)
}
// Enforcement : le membre lit (GET file), l'outsider non.
ra, err := s.Repository.Shares.EffectiveAccess(memberID, fileID)
if err != nil || !ra.Accessible || ra.EffectiveRank != repository.AccessEditor {
t.Errorf("EffectiveAccess membre = %+v err=%v, attendu editor", ra, err)
}
row, err := s.Repo.GetFileVisible(memberID, fileID)
if err != nil || row.ID != fileID {
t.Errorf("membre doit voir le fichier : %+v err=%v", row, err)
}
if _, err := s.Repo.GetFileVisible(outsiderID, fileID); err == nil {
t.Errorf("outsider ne doit pas voir le fichier")
}
// Owner listing : grant kind=group au nom du groupe.
grants, err := s.ListShares(ownerID, fileID)
if err != nil || len(grants) != 1 {
t.Fatalf("ListShares = %+v err=%v", grants, err)
}
if grants[0].GranteeKind != "group" || grants[0].GranteeUserID != groupID || grants[0].Username != "Famille" {
t.Errorf("grant groupe = %+v", grants[0])
}
// Retrait du membre → disparaît du snapshot au pull complet.
if err := s.Repository.Groups.RemoveMember(groupID, memberID); err != nil {
t.Fatalf("remove member: %v", err)
}
perms, err = s.Snapshot(memberID, 0)
if err != nil {
t.Fatalf("Snapshot après retrait: %v", err)
}
if len(perms) != 0 {
t.Errorf("snapshot après retrait = %+v, attendu vide", perms)
}
// Suppression du groupe → plus de partage (cascade FK).
member2 := mustCreateUser(t, s.Repository, "grp-member2")
if err := s.Repository.Groups.AddMember(groupID, member2); err != nil {
t.Fatalf("add member2: %v", err)
}
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{
"granteeGroupId": groupID,
"access": "viewer",
}),
}); err != nil {
t.Fatalf("re-share: %v", err)
}
if err := s.DeleteGroup(ownerID, groupID); err != nil {
t.Fatalf("delete group: %v", err)
}
perms, err = s.Snapshot(member2, 0)
if err != nil {
t.Fatalf("Snapshot après delete: %v", err)
}
if len(perms) != 0 {
t.Errorf("snapshot après delete groupe = %+v, attendu vide", perms)
}
}
func TestGroupShareValidation(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "grpval-owner")
deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID)
fileID := repository.NewID()
if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "v.txt"}),
}); err != nil {
t.Fatalf("create: %v", err)
}
apply := func(payload map[string]any) (SyncResult, error) {
return s.ApplyBatch(ownerID, deviceID, []SyncOperation{
syncOp(repository.NewID(), fileID, OpShare, "file", payload),
})
}
// Groupe inconnu → GROUP_NOT_FOUND.
denied, err := apply(map[string]any{"granteeGroupId": repository.NewID(), "access": "viewer"})
if err != nil || denied.Applied != 0 || denied.Failed == nil || denied.Failed.Code != "GROUP_NOT_FOUND" {
t.Errorf("groupe inconnu: attendu halt GROUP_NOT_FOUND, got %+v err=%v", denied, err)
}
// Deux cibles → INVALID_REQUEST.
both, err := apply(map[string]any{
"granteeUserId": ownerID, "granteeGroupId": repository.NewID(), "access": "viewer",
})
if err != nil || both.Applied != 0 || both.Failed == nil || both.Failed.Code != "INVALID_REQUEST" {
t.Errorf("deux cibles: attendu halt INVALID_REQUEST, got %+v err=%v", both, err)
}
// Aucune cible → INVALID_REQUEST.
none, err := apply(map[string]any{"access": "viewer"})
if err != nil || none.Applied != 0 || none.Failed == nil || none.Failed.Code != "INVALID_REQUEST" {
t.Errorf("sans cible: attendu halt INVALID_REQUEST, got %+v err=%v", none, err)
}
}
func TestGroupManagementScoping(t *testing.T) {
s := newServiceStore(t)
ownerID := mustCreateUser(t, s.Repository, "gm-owner")
otherID := mustCreateUser(t, s.Repository, "gm-other")
memberID := mustCreateUser(t, s.Repository, "gm-member")
group, err := s.CreateGroup(ownerID, " Équipe ")
if err != nil {
t.Fatalf("create: %v", err)
}
if group.Name != "Équipe" || group.Role != "owner" {
t.Errorf("groupe = %+v (nom trimé attendu)", group)
}
if _, err := s.CreateGroup(ownerID, " "); err == nil {
t.Errorf("nom vide attendu rejeté")
}
// Non-owner ne peut ni ajouter ni supprimer.
if err := s.AddGroupMember(otherID, group.ID, memberID); err == nil {
t.Errorf("add par non-owner attendu refusé")
}
if err := s.AddGroupMember(ownerID, group.ID, memberID); err != nil {
t.Fatalf("add: %v", err)
}
// Membre inexistant → GRANTEE_NOT_FOUND.
if err := s.AddGroupMember(ownerID, group.ID, repository.NewID()); err != repository.ErrGranteeNotFound {
t.Errorf("membre inconnu: attendu ErrGranteeNotFound, got %v", err)
}
if err := s.RemoveGroupMember(otherID, group.ID, memberID); err == nil {
t.Errorf("remove par non-owner attendu refusé")
}
// Listes : owner voit (owner), membre voit (member), tiers ne voit rien.
owned, _ := s.ListGroups(ownerID)
if len(owned) != 1 || owned[0].Role != "owner" {
t.Errorf("list owner = %+v", owned)
}
joined, _ := s.ListGroups(memberID)
if len(joined) != 1 || joined[0].Role != "member" {
t.Errorf("list member = %+v", joined)
}
none, _ := s.ListGroups(otherID)
if len(none) != 0 {
t.Errorf("list tiers = %+v, attendu vide", none)
}
if err := s.DeleteGroup(otherID, group.ID); err == nil {
t.Errorf("delete par non-owner attendu refusé")
}
if err := s.DeleteGroup(ownerID, group.ID); err != nil {
t.Fatalf("delete: %v", err)
}
}
+9 -1
View File
@@ -9,8 +9,11 @@ import (
// ShareGrantDTO serializes one active grant for GET /files/:id/shares.
// Milliseconds epoch (null = never), mirroring the permissions snapshot
// (docs/api-v1.md §6.2) for cheap client-side expiry checks.
// `granteeKind` is "user" or "group" (V2-6) ; `granteeUserId` carries the
// principal id either way, `username` its display name.
type ShareGrantDTO struct {
GranteeUserID string `json:"granteeUserId"`
GranteeKind string `json:"granteeKind"`
Username string `json:"username"`
Access string `json:"access"`
Inherit bool `json:"inherit"`
@@ -51,8 +54,13 @@ func (s *Resources) ListShares(userID, resourceID string) ([]ShareGrantDTO, erro
ms := g.ExpiresAt.UnixMilli()
expires = &ms
}
granteeID := g.GranteeUserID
if g.GranteeGroupID != "" {
granteeID = g.GranteeGroupID
}
out = append(out, ShareGrantDTO{
GranteeUserID: g.GranteeUserID,
GranteeUserID: granteeID,
GranteeKind: g.GrantKind(),
Username: g.Username,
Access: g.Access,
Inherit: g.Inherit,
+38 -16
View File
@@ -67,10 +67,11 @@ type movePayload struct {
}
type sharePayload struct {
GranteeUserID string `json:"granteeUserId"`
Access string `json:"access"`
Inherit *bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
GranteeUserID string `json:"granteeUserId"`
GranteeGroupID string `json:"granteeGroupId"`
Access string `json:"access"`
Inherit *bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
}
type revokeSharePayload struct {
@@ -99,6 +100,8 @@ func classifySyncError(err error) (string, string) {
return "NOT_FOUND", "target resource or folder not found"
case errors.Is(err, repository.ErrGranteeNotFound):
return "GRANTEE_NOT_FOUND", "the specified user does not exist"
case errors.Is(err, repository.ErrGroupNotFound):
return "GROUP_NOT_FOUND", "the specified group does not exist"
case errors.Is(err, repository.ErrPayloadMismatch):
return "INVALID_REQUEST", "operation replayed with different payload"
case errors.Is(err, errCycle):
@@ -383,23 +386,22 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
if err := json.Unmarshal(op.Payload, &p); err != nil {
return errors.New("invalid payload: " + err.Error())
}
if p.GranteeUserID == "" {
return errors.New("payload.granteeUserId required")
// Cible : exactement un principal (user XOR groupe, V2-6).
isUser := p.GranteeUserID != ""
isGroup := p.GranteeGroupID != ""
if isUser == isGroup {
return errors.New("payload requires exactly one of granteeUserId, granteeGroupId")
}
if !resourceIDPattern.MatchString(p.GranteeUserID) {
if isUser && !resourceIDPattern.MatchString(p.GranteeUserID) {
return errors.New("payload.granteeUserId must be 32 lowercase hex chars")
}
if isGroup && !resourceIDPattern.MatchString(p.GranteeGroupID) {
return errors.New("payload.granteeGroupId must be 32 lowercase hex chars")
}
rank := repository.AccessFromString(p.Access)
if rank < repository.AccessViewer || rank > repository.AccessEditor {
return errors.New("payload.access must be viewer, commenter, or editor")
}
// Validate grantee exists and is active.
if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
inherit := true
if p.Inherit != nil {
inherit = *p.Inherit
@@ -412,8 +414,28 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation)
}
expiresAt = &t
}
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
if isUser {
// Validate grantee exists and is active.
if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGranteeNotFound
}
return err
}
if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
} else {
// Validate group exists (any group : ids are unguessable, no enum).
if _, err := s.Repository.Groups.Get(p.GranteeGroupID); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return repository.ErrGroupNotFound
}
return err
}
if err := s.Repository.Shares.UpsertGroup(resourceID, p.GranteeGroupID, p.Access, inherit, expiresAt, ownerID); err != nil {
return err
}
}
// Bump resource updated_at so the grantee's delta snapshot picks it up.
// Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le