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
+2 -1
View File
@@ -8,7 +8,8 @@ MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng
# Sécurité — à changer en production (jamais commité)
AUTH_SECRET=dev-secret-change-me
# ≥ 32 caractères, ex. `openssl rand -hex 32`. Doit matcher config.go (min 32).
AUTH_SECRET=dev-secret-change-me-please-set-in-prod
# Premier admin (créé UNIQUEMENT si la table users est vide). Obligatoires au
# premier démarrage ; ignorés ensuite (l'env n'écrase jamais un compte).
+7
View File
@@ -27,6 +27,13 @@ var expectedRoutes = []string{
"GET /api/v1/users/resolve",
"PATCH /api/v1/users/me/password",
"POST /api/v1/groups",
"GET /api/v1/groups",
"POST /api/v1/groups/:id/members",
"GET /api/v1/groups/:id/members",
"DELETE /api/v1/groups/:id/members/:userId",
"DELETE /api/v1/groups/:id",
"POST /api/v1/ocr/jobs",
"GET /api/v1/ocr/jobs/:id",
@@ -0,0 +1,6 @@
DROP INDEX IF EXISTS idx_shares_active_group;
ALTER TABLE shares DROP CONSTRAINT IF EXISTS shares_grantee_xor_check;
ALTER TABLE shares ALTER COLUMN grantee_user_id SET NOT NULL;
ALTER TABLE shares DROP COLUMN IF EXISTS grantee_group_id;
DROP TABLE IF EXISTS group_members;
DROP TABLE IF EXISTS groups;
@@ -0,0 +1,32 @@
-- V2-6 groupes : partage vers un ensemble d'utilisateurs (famille, équipe).
-- `groups` : identité nommée possédée (created_by) ; `group_members` :
-- appartenances (pas de groupes imbriqués — un niveau, documenté).
-- `shares` accepte une cible groupe : exactement une des deux cibles est
-- renseignée (CHECK), avec un index d'unicité active par cible.
CREATE TABLE groups (
id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'),
name TEXT NOT NULL CHECK (name <> '' AND char_length(name) <= 255),
created_by TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
CREATE TABLE group_members (
group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ DEFAULT NOW(),
PRIMARY KEY (group_id, user_id)
);
CREATE INDEX idx_group_members_user ON group_members(user_id);
ALTER TABLE shares ADD COLUMN grantee_group_id TEXT REFERENCES groups(id) ON DELETE CASCADE;
ALTER TABLE shares ALTER COLUMN grantee_user_id DROP NOT NULL;
ALTER TABLE shares
ADD CONSTRAINT shares_grantee_xor_check
CHECK (
(grantee_user_id IS NOT NULL AND grantee_group_id IS NULL)
OR (grantee_user_id IS NULL AND grantee_group_id IS NOT NULL)
);
CREATE UNIQUE INDEX idx_shares_active_group
ON shares(resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL;
+19
View File
@@ -349,6 +349,25 @@ func TestMigrationsUpDown(t *testing.T) {
assertHexCheck(t, conn, "storage_locations", "id")
assertHexCheck(t, conn, "storage_locations", "device_id")
assertHexCheck(t, conn, "groups", "id")
// shares XOR : exactement une cible (user ou groupe).
var xorCheck int
err = conn.QueryRow(`
SELECT COUNT(*) FROM pg_constraint c
JOIN pg_class t ON t.oid = c.conrelid
WHERE t.relname = 'shares'
AND pg_get_constraintdef(c.oid) LIKE '%grantee_user_id%'
AND pg_get_constraintdef(c.oid) LIKE '%grantee_group_id%'`).Scan(&xorCheck)
if err != nil {
t.Fatalf("shares xor check: %v", err)
}
if xorCheck == 0 {
t.Error("CHECK XOR (grantee_user_id / grantee_group_id) manquant sur shares après 000016")
}
// --- 000016 : groupes + cible groupe sur shares -------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "schema_migrations")
if err := MigrateDownDatabase(url); err != nil {
t.Fatalf("migrate down: %v", err)
+143
View File
@@ -0,0 +1,143 @@
package handlers
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
"github.com/kazier/backend/service"
)
// groupIDParam validates a 32-hex group id path param (404, never 400 —
// group ids are unguessable, no enumeration).
func groupIDParam(c *gin.Context, name string) (string, bool) {
id := c.Param(name)
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "group not found")
return "", false
}
return id, true
}
// GroupsCreate stores an owned group : POST /groups {name}.
func GroupsCreate(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
var body struct {
Name string `json:"name"`
}
if err := c.ShouldBindJSON(&body); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body")
return
}
dto, err := Store.CreateGroup(c.GetString(UserIDKey), body.Name)
if err != nil {
if errors.Is(err, service.ErrInvalidUpload) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid group name")
return
}
writeError(c, err)
return
}
api.OK(c, dto)
}
// GroupsList returns owned + joined groups : GET /groups.
func GroupsList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
dtos, err := Store.ListGroups(c.GetString(UserIDKey))
if err != nil {
writeError(c, err)
return
}
api.OK(c, dtos)
}
// GroupMembersAdd adds an existing user : POST /groups/:id/members {userId}.
func GroupMembersAdd(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
var body struct {
UserID string `json:"userId"`
}
if err := c.ShouldBindJSON(&body); err != nil || !deviceIDPattern.MatchString(body.UserID) {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `userId`")
return
}
if err := Store.AddGroupMember(c.GetString(UserIDKey), groupID, body.UserID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupMembersRemove removes a membership :
// DELETE /groups/:id/members/:userId.
func GroupMembersRemove(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
memberID, ok := groupIDParam(c, "userId")
if !ok {
return
}
if err := Store.RemoveGroupMember(c.GetString(UserIDKey), groupID, memberID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupsDelete removes an owned group : DELETE /groups/:id.
func GroupsDelete(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
if err := Store.DeleteGroup(c.GetString(UserIDKey), groupID); err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": groupID})
}
// GroupMembersList returns memberships of an owned group :
// GET /groups/:id/members.
func GroupMembersList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
groupID, ok := groupIDParam(c, "id")
if !ok {
return
}
members, err := Store.ListMembers(c.GetString(UserIDKey), groupID)
if err != nil {
writeError(c, err)
return
}
api.OK(c, members)
}
+108
View File
@@ -0,0 +1,108 @@
package handlers_test
import (
"encoding/json"
"fmt"
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// V2-6 : CRUD groupes + membres via HTTP, scoping owner, 404 sans énumération.
func TestGroupsHttpFlow(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, _ := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "go"), "groups-http-password", ownerDevice)
otherDevice := repository.NewID()
otherToken, _ := registerAndLogin(t, r, repo, testUserUsername(otherDevice, "gx"), "groups-http-password-b", otherDevice)
// Création (nom trimé).
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" Famille "}`), "application/json")
env := expectOK(t, rec, "groups-create")
var created struct {
ID string `json:"id"`
Name string `json:"name"`
Role string `json:"role"`
}
if err := json.Unmarshal(env.Data, &created); err != nil {
t.Fatalf("groups-create: unmarshal: %v", err)
}
if created.Name != "Famille" || created.Role != "owner" {
t.Errorf("groups-create = %+v", created)
}
// Nom vide → 400.
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" "}`), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "groups-create-blank")
// Liste owner (1, owner) ; tiers (0).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", ownerToken, nil, "")
env = expectOK(t, rec, "groups-list-owner")
var listed []map[string]any
if err := json.Unmarshal(env.Data, &listed); err != nil {
t.Fatalf("groups-list: unmarshal: %v", err)
}
if len(listed) != 1 {
t.Errorf("groups-list-owner = %d, attendu 1", len(listed))
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", otherToken, nil, "")
env = expectOK(t, rec, "groups-list-other")
listed = nil
if err := json.Unmarshal(env.Data, &listed); err != nil {
t.Fatalf("groups-list-other: unmarshal: %v", err)
}
if len(listed) != 0 {
t.Errorf("groups-list-other = %d, attendu 0", len(listed))
}
// Ajout membre : besoin d'un user existant — on le crée via un login.
memberDevice := repository.NewID()
_, memberID := registerAndLogin(t, r, repo, testUserUsername(memberDevice, "gm"), "groups-http-password-c", memberDevice)
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json",
)
expectOK(t, rec, "groups-add-member")
// Liste membres (owner) : le membre ajouté ; tiers → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", ownerToken, nil, "")
envMembers := expectOK(t, rec, "groups-list-members")
var members []map[string]any
if err := json.Unmarshal(envMembers.Data, &members); err != nil {
t.Fatalf("groups-list-members: unmarshal: %v", err)
}
if len(members) != 1 || members[0]["id"] != memberID {
t.Errorf("groups-list-members = %v, attendu 1 membre", members)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", otherToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-list-members-other")
// Non-owner → 404.
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", otherToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json",
)
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-other")
// Membre inconnu → GRANTEE_NOT_FOUND.
rec, _ = doRequest(
t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, repository.NewID())), "application/json",
)
expectError(t, rec, http.StatusNotFound, "GRANTEE_NOT_FOUND", "groups-add-unknown")
// Groupe inconnu → 404 partout (pas d'énumération).
unknown := repository.NewID()
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups/"+unknown+"/members", ownerToken,
[]byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-unknown-group")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+unknown, ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-unknown")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/not-hex", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-invalid-id")
// Retrait puis suppression.
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID+"/members/"+memberID, ownerToken, nil, "")
expectOK(t, rec, "groups-remove-member")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, otherToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-other")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, ownerToken, nil, "")
expectOK(t, rec, "groups-delete")
}
+7
View File
@@ -43,6 +43,13 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/users/resolve", ResolveUser)
protected.PATCH("/users/me/password", ChangePassword)
protected.POST("/groups", GroupsCreate)
protected.GET("/groups", GroupsList)
protected.POST("/groups/:id/members", GroupMembersAdd)
protected.GET("/groups/:id/members", GroupMembersList)
protected.DELETE("/groups/:id/members/:userId", GroupMembersRemove)
protected.DELETE("/groups/:id", GroupsDelete)
protected.POST("/ocr/jobs", OcrJobsCreate)
protected.GET("/ocr/jobs/:id", OcrJobsGet)
+2
View File
@@ -24,6 +24,8 @@ func writeError(c *gin.Context, err error) {
api.Error(c, 404, "NOT_FOUND", "resource not found")
case errors.Is(err, repository.ErrGranteeNotFound):
api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist")
case errors.Is(err, repository.ErrGroupNotFound):
api.Error(c, 404, "GROUP_NOT_FOUND", "the specified group does not exist")
case errors.Is(err, repository.ErrNameConflict):
api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here")
case errors.Is(err, service.ErrFileTooLarge):
+185
View File
@@ -0,0 +1,185 @@
package repository
import (
"database/sql"
"errors"
)
// Group is a named set of users (V2-6) : sharing to a group grants every
// member. One level only (no nested groups). The creator owns the group
// (member management + deletion) ; membership confers no admin rights.
type Group struct {
ID string
Name string
CreatedBy string
}
// Groups implements group persistence.
type Groups struct {
DB *sql.DB
}
// Create stores a group owned by ownerID and returns its id.
func (g *Groups) Create(name, ownerID string) (string, error) {
id := NewID()
_, err := g.DB.Exec(
`INSERT INTO groups (id, name, created_by) VALUES ($1, $2, $3)`,
id, name, ownerID,
)
if err != nil {
return "", err
}
return id, nil
}
// Get returns a group by id. No-rows → ErrNotFound.
func (g *Groups) Get(groupID string) (Group, error) {
var group Group
err := g.DB.QueryRow(
`SELECT id, name, created_by FROM groups WHERE id = $1`,
groupID,
).Scan(&group.ID, &group.Name, &group.CreatedBy)
if errors.Is(err, sql.ErrNoRows) {
return Group{}, ErrNotFound
}
return group, err
}
// IsOwner reports whether userID created the group.
func (g *Groups) IsOwner(groupID, userID string) (bool, error) {
var n int
err := g.DB.QueryRow(
`SELECT COUNT(*) FROM groups WHERE id = $1 AND created_by = $2`,
groupID, userID,
).Scan(&n)
return n > 0, err
}
// IsMember reports group membership (owner excluded : ownership is separate).
func (g *Groups) IsMember(groupID, userID string) (bool, error) {
var n int
err := g.DB.QueryRow(
`SELECT COUNT(*) FROM group_members WHERE group_id = $1 AND user_id = $2`,
groupID, userID,
).Scan(&n)
return n > 0, err
}
// GroupWithRole is a group listing row (owned or joined).
type GroupWithRole struct {
Group
Role string // "owner" | "member"
}
// ListForUser returns groups the user owns or joins, owned first.
func (g *Groups) ListForUser(userID string) ([]GroupWithRole, error) {
rows, err := g.DB.Query(
`SELECT id, name, created_by,
CASE WHEN created_by = $1 THEN 'owner' ELSE 'member' END AS role
FROM groups
WHERE created_by = $1 OR id IN (SELECT group_id FROM group_members WHERE user_id = $1)
ORDER BY created_at ASC`,
userID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []GroupWithRole
for rows.Next() {
var gr GroupWithRole
if err := rows.Scan(&gr.ID, &gr.Name, &gr.CreatedBy, &gr.Role); err != nil {
return nil, err
}
out = append(out, gr)
}
return out, rows.Err()
}
// AddMember inserts a membership. Idempotent on replay (ON CONFLICT DO
// NOTHING) ; returns rows-affected style via ErrNotFound when the group or
// the user does not exist (FK violation mapped).
func (g *Groups) AddMember(groupID, userID string) error {
_, err := g.DB.Exec(
`INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
ON CONFLICT DO NOTHING`,
groupID, userID,
)
if isForeignKeyViolation(err) {
return ErrNotFound
}
return err
}
// RemoveMember deletes a membership. Missing row → ErrNotFound.
func (g *Groups) RemoveMember(groupID, userID string) error {
result, err := g.DB.Exec(
`DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`,
groupID, userID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
// Member is a group membership row (owner view).
type Member struct {
UserID string
Username string
}
// ListMembers returns memberships of a group, ordered by username.
func (g *Groups) ListMembers(groupID string) ([]Member, error) {
rows, err := g.DB.Query(
`SELECT u.id, COALESCE(u.username, u.id)
FROM group_members gm
JOIN users u ON u.id = gm.user_id AND u.deleted_at IS NULL
WHERE gm.group_id = $1
ORDER BY COALESCE(u.username, u.id) ASC`,
groupID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Member
for rows.Next() {
var m Member
if err := rows.Scan(&m.UserID, &m.Username); err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
// Errors specific to groups.
var ErrGroupNotFound = errors.New("group not found")
// Delete removes a group (owner only — caller checks). Shares targeting it
// cascade (FK), placements are untouched (device-scoped, not group-scoped).
func (g *Groups) Delete(groupID, ownerID string) error {
result, err := g.DB.Exec(
`DELETE FROM groups WHERE id = $1 AND created_by = $2`,
groupID, ownerID,
)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrNotFound
}
return nil
}
+2
View File
@@ -13,6 +13,7 @@ type Repository struct {
Users *Users
Shares *Shares
Placements *Placements
Groups *Groups
}
func NewRepository(conn *sql.DB) *Repository {
@@ -24,5 +25,6 @@ func NewRepository(conn *sql.DB) *Repository {
Users: &Users{DB: conn},
Shares: &Shares{DB: conn},
Placements: &Placements{DB: conn},
Groups: &Groups{DB: conn},
}
}
+1 -1
View File
@@ -113,7 +113,7 @@ const grantedCTE = `
sh.inherit, 0
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL
WHERE ` + granteeMatch + ` AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
),
+69 -20
View File
@@ -71,11 +71,19 @@ type ResourceAccess struct {
Inherit bool
}
// Shares implements share persistence for user-to-user grants.
// Shares implements share persistence for user-to-user AND user-to-group
// grants (V2-6). A grant targets exactly one principal (shares XOR CHECK) :
// `grantee_user_id` for a user, `grantee_group_id` for a group (every member
// inherits, one level, no nesting).
type Shares struct {
DB *sql.DB
}
// granteeMatch matches the grants visible to a user: direct user grants plus
// grants to any group they belong to. `$1` is always the user id in the
// enclosing query (snapshot, enforcement, visibility CTEs).
const granteeMatch = `(sh.grantee_user_id = $1 OR sh.grantee_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))`
// Upsert inserts or updates an active share. On conflict (active row for
// same resource + grantee) the access, inherit, and expires_at are updated.
func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool, expiresAt *time.Time, createdBy string) error {
@@ -96,12 +104,13 @@ func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool,
return err
}
// Revoke soft-revokes the active share between a resource and a grantee.
func (s *Shares) Revoke(resourceID, granteeUserID string) error {
// Revoke soft-revokes the active share between a resource and a grantee
// (user id or group id — ids are unguessable 32-hex, globally unique).
func (s *Shares) Revoke(resourceID, granteeID string) error {
result, err := s.DB.Exec(
`UPDATE shares SET revoked_at = NOW(), updated_at = NOW()
WHERE resource_id = $1 AND grantee_user_id = $2 AND revoked_at IS NULL`,
resourceID, granteeUserID,
WHERE resource_id = $1 AND (grantee_user_id = $2 OR grantee_group_id = $2) AND revoked_at IS NULL`,
resourceID, granteeID,
)
if err != nil {
return err
@@ -153,7 +162,7 @@ seeded(id, type, updated_at, parent_id, grant_rank, created_by, expires_at, gran
sh.created_by, sh.expires_at, sh.inherit, r.name, TRUE
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL
WHERE `+granteeMatch+` AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
),
@@ -263,7 +272,7 @@ direct AS (
SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END AS rank
FROM shares sh
JOIN resources r ON r.resource_id = sh.resource_id
WHERE sh.resource_id = $2 AND sh.grantee_user_id = $1
WHERE sh.resource_id = $2 AND `+granteeMatch+`
AND sh.revoked_at IS NULL
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())
AND r.deleted_at IS NULL
@@ -276,7 +285,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh
WHERE sh.resource_id = r.parent_id AND sh.grantee_user_id = $1
WHERE sh.resource_id = r.parent_id AND `+granteeMatch+`
AND sh.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
0
@@ -286,7 +295,7 @@ inherited(id, grant_rank, depth) AS (
SELECT r.parent_id,
COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END
FROM shares sh
WHERE sh.resource_id = ag.id AND sh.grantee_user_id = $1
WHERE sh.resource_id = ag.id AND `+granteeMatch+`
AND sh.revoked_at IS NULL AND sh.inherit
AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0),
ag.depth + 1
@@ -455,14 +464,44 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro
return links, rows.Err()
}
// ShareGrant is one active user-to-user grant on a resource (owner view).
// ShareGrant is one active grant on a resource (owner view). Exactly one of
// GranteeUserID / GranteeGroupID is set (mirrors the shares XOR CHECK).
type ShareGrant struct {
GranteeUserID string
Username string
Access string
Inherit bool
ExpiresAt *time.Time
UpdatedAt time.Time
GranteeUserID string
GranteeGroupID string
Username string
Access string
Inherit bool
ExpiresAt *time.Time
UpdatedAt time.Time
}
// GrantKind returns "group" for group-targeted grants, "user" otherwise.
func (g ShareGrant) GrantKind() string {
if g.GranteeGroupID != "" {
return "group"
}
return "user"
}
// UpsertGroup inserts or updates an active group-targeted share. Same
// idempotent semantics as Upsert, keyed by (resource, group).
func (s *Shares) UpsertGroup(resourceID, groupID, access string, inherit bool, expiresAt *time.Time, createdBy string) error {
var expires any
if expiresAt != nil {
expires = *expiresAt
}
_, err := s.DB.Exec(
`INSERT INTO shares (id, resource_id, grantee_group_id, access, inherit, created_by, expires_at)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL
DO UPDATE SET access = EXCLUDED.access,
inherit = EXCLUDED.inherit,
expires_at = EXCLUDED.expires_at,
updated_at = NOW()`,
NewID(), resourceID, groupID, access, inherit, createdBy, expires,
)
return err
}
// ListActiveForResource returns the active (non-revoked) grants on a resource,
@@ -470,10 +509,12 @@ type ShareGrant struct {
// the caller filters display. Empty (not error) when nothing is shared.
func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error) {
rows, err := s.DB.Query(
`SELECT s.grantee_user_id, COALESCE(u.username, s.grantee_user_id),
`SELECT s.grantee_user_id, s.grantee_group_id,
COALESCE(u.username, gr.name, COALESCE(s.grantee_user_id, s.grantee_group_id)),
s.access, s.inherit, s.expires_at, s.updated_at
FROM shares s
LEFT JOIN users u ON u.id = s.grantee_user_id AND u.deleted_at IS NULL
LEFT JOIN groups gr ON gr.id = s.grantee_group_id
WHERE s.resource_id = $1 AND s.revoked_at IS NULL
ORDER BY s.created_at ASC`,
resourceID,
@@ -485,12 +526,20 @@ func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error)
var grants []ShareGrant
for rows.Next() {
var (
g ShareGrant
expiresAt sql.NullTime
g ShareGrant
granteeUser sql.NullString
granteeGrp sql.NullString
expiresAt sql.NullTime
)
if err := rows.Scan(&g.GranteeUserID, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil {
if err := rows.Scan(&granteeUser, &granteeGrp, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil {
return nil, err
}
if granteeUser.Valid {
g.GranteeUserID = granteeUser.String
}
if granteeGrp.Valid {
g.GranteeGroupID = granteeGrp.String
}
if expiresAt.Valid {
g.ExpiresAt = &expiresAt.Time
}
+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