follow sql schema

This commit is contained in:
venture
2026-11-14 09:52:18 +01:00
parent f7649f24ef
commit 276a9fe320
23 changed files with 855 additions and 548 deletions
+124
View File
@@ -0,0 +1,124 @@
package identity
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"mediarr/database"
"mediarr/ident"
)
func GroupNameForRole(role string) (string, error) {
switch role {
case RoleAdmin:
return "admins", nil
case RoleMember:
return "members", nil
default:
return "", fmt.Errorf("%w: %q", ErrInvalidRole, role)
}
}
func (s *Service) AddMember(ctx context.Context, groupID, memberID ident.UUID, role string) error {
if role == "" {
role = RoleMember
}
if role != RoleAdmin && role != RoleMember {
return fmt.Errorf("%w: %q", ErrInvalidRole, role)
}
group, err := s.db.Queries.GetPrincipal(ctx, groupID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrGroupNotFound
}
return err
}
if group.Kind != KindGroup {
return fmt.Errorf("%w: %s", ErrInvalidGroup, group.Kind)
}
member, err := s.db.Queries.GetPrincipal(ctx, memberID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrInvalidMember
}
return err
}
if member.Kind != KindUser && member.Kind != KindGuest {
return fmt.Errorf("%w: %s", ErrInvalidMember, member.Kind)
}
_, err = s.db.WriteQueries.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: groupID,
MemberID: memberID,
Role: role,
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
if isUniqueViolation(err) {
return fmt.Errorf("%w: %s dans %s", ErrAlreadyMember, member.Name, group.Name)
}
return err
}
return nil
}
func (s *Service) RemoveMember(ctx context.Context, groupID, memberID ident.UUID) error {
_, err := s.db.Queries.GetMembership(ctx, database.GetMembershipParams{
GroupID: groupID,
MemberID: memberID,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ErrNotMember
}
return err
}
return s.db.WriteQueries.DeleteMembership(ctx, database.DeleteMembershipParams{
GroupID: groupID,
MemberID: memberID,
})
}
func (s *Service) ListGroups(ctx context.Context, memberID ident.UUID) ([]Group, error) {
rows, err := s.db.Queries.ListMemberGroupsWithRole(ctx, memberID)
if err != nil {
return nil, err
}
groups := make([]Group, 0, len(rows))
for _, row := range rows {
groups = append(groups, Group{
ID: row.ID,
Name: row.Name,
Role: row.Role,
})
}
return groups, nil
}
func (s *Service) ListGroupMembers(ctx context.Context, groupID ident.UUID) ([]Member, error) {
rows, err := s.db.Queries.ListGroupMembersWithRole(ctx, groupID)
if err != nil {
return nil, err
}
members := make([]Member, 0, len(rows))
for _, row := range rows {
members = append(members, Member{
ID: row.ID,
Name: row.Name,
Kind: row.Kind,
Role: row.Role,
})
}
return members, nil
}
+107
View File
@@ -0,0 +1,107 @@
package identity
import (
"context"
"errors"
"testing"
)
func TestAddAndRemoveMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
admins := mustGroup(t, service, "admins")
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
t.Fatalf("AddMember(members) : %v", err)
}
if err := service.AddMember(ctx, admins.ID, user.ID, RoleAdmin); err != nil {
t.Fatalf("AddMember(admins) : %v", err)
}
groups, err := service.ListGroups(ctx, user.ID)
if err != nil {
t.Fatalf("ListGroups : %v", err)
}
if !hasGroup(groups, "members") || !hasGroup(groups, "admins") {
t.Fatalf("groupes = %+v, attendu members et admins", groups)
}
list, err := service.ListGroupMembers(ctx, admins.ID)
if err != nil {
t.Fatalf("ListGroupMembers : %v", err)
}
if len(list) != 1 || list[0].ID != user.ID || list[0].Role != RoleAdmin {
t.Fatalf("membres = %+v, attendu alice admin", list)
}
if err := service.RemoveMember(ctx, admins.ID, user.ID); err != nil {
t.Fatalf("RemoveMember : %v", err)
}
if err := service.RemoveMember(ctx, admins.ID, user.ID); !errors.Is(err, ErrNotMember) {
t.Fatalf("erreur = %v, attendu ErrNotMember", err)
}
}
func TestAddMemberRejectsDuplicate(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
if err := service.AddMember(ctx, members.ID, user.ID, RoleMember); err != nil {
t.Fatalf("AddMember : %v", err)
}
err := service.AddMember(ctx, members.ID, user.ID, RoleMember)
if !errors.Is(err, ErrAlreadyMember) {
t.Fatalf("erreur = %v, attendu ErrAlreadyMember", err)
}
}
func TestAddMemberRejectsInvalidMember(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
user := mustCreatePrincipal(t, service, KindUser, "alice")
members := mustGroup(t, service, "members")
err := service.AddMember(ctx, members.ID, members.ID, RoleMember)
if !errors.Is(err, ErrInvalidMember) {
t.Fatalf("erreur = %v, attendu ErrInvalidMember", err)
}
err = service.AddMember(ctx, user.ID, user.ID, RoleMember)
if !errors.Is(err, ErrInvalidGroup) {
t.Fatalf("erreur = %v, attendu ErrInvalidGroup", err)
}
}
func TestGroupNameForRole(t *testing.T) {
name, err := GroupNameForRole(RoleAdmin)
if err != nil || name != "admins" {
t.Fatalf("admin : name = %q, err = %v", name, err)
}
name, err = GroupNameForRole(RoleMember)
if err != nil || name != "members" {
t.Fatalf("member : name = %q, err = %v", name, err)
}
if _, err := GroupNameForRole("super-admin"); !errors.Is(err, ErrInvalidRole) {
t.Fatalf("erreur = %v, attendu ErrInvalidRole", err)
}
}
func hasGroup(groups []Group, name string) bool {
for _, group := range groups {
if group.Name == name {
return true
}
}
return false
}
+55
View File
@@ -0,0 +1,55 @@
package identity
import (
"context"
"testing"
"mediarr/database"
)
func newTestService(t *testing.T) *Service {
t.Helper()
t.Chdir(t.TempDir())
err, db := database.NewDatabase(database.NewDatabaseParams{})
if err != nil {
t.Fatalf("NewDatabase : %v", err)
}
t.Cleanup(func() {
if err := db.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
return NewService(*db)
}
func mustCreatePrincipal(t *testing.T, service *Service, kind, name string) *Principal {
t.Helper()
created, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: kind,
Name: name,
})
if err != nil {
t.Fatalf("CreatePrincipal(%q) : %v", name, err)
}
return created
}
func mustGroup(t *testing.T, service *Service, name string) database.Principal {
t.Helper()
group, err := service.db.Queries.GetPrincipalByNameAndKind(context.Background(), database.GetPrincipalByNameAndKindParams{
Kind: KindGroup,
Name: name,
})
if err != nil {
t.Fatalf("groupe %q : %v", name, err)
}
return group
}
+55
View File
@@ -0,0 +1,55 @@
package identity
import (
"errors"
"mediarr/ident"
)
const (
KindCluster = "cluster"
KindUser = "user"
KindGuest = "guest"
KindGroup = "group"
KindSystem = "system"
)
const (
RoleAdmin = "admin"
RoleMember = "member"
)
type Principal struct {
ID ident.UUID
Kind string
Name string
Status string
CreatedAt int64
Groups []Group
}
type Group struct {
ID ident.UUID
Name string
Role string
}
type Member struct {
ID ident.UUID
Name string
Kind string
Role string
}
var (
ErrInvalidRole = errors.New("rôle invalide")
ErrAlreadyMember = errors.New("membre déjà présent dans le groupe")
ErrNotMember = errors.New("membre absent du groupe")
ErrInvalidMember = errors.New("membre invalide : utilisateur ou invité attendu")
ErrInvalidGroup = errors.New("groupe invalide")
ErrGroupNotFound = errors.New("groupe introuvable")
ErrNameTaken = errors.New("nom déjà utilisé")
ErrInvalidKind = errors.New("type de principal invalide")
ErrInvalidName = errors.New("nom invalide")
ErrInvalidStatus = errors.New("statut de principal invalide")
)
+142
View File
@@ -0,0 +1,142 @@
package identity
import (
"context"
"fmt"
"strings"
"time"
"mediarr/database"
"mediarr/ident"
)
const maxNameLen = 255
type CreatePrincipalParams struct {
Kind string
Name string
PublicKey []byte
Status string
}
func (s *Service) CreatePrincipal(ctx context.Context, params CreatePrincipalParams) (*Principal, error) {
if !validKind(params.Kind) {
return nil, fmt.Errorf("%w: %q", ErrInvalidKind, params.Kind)
}
name := strings.TrimSpace(params.Name)
if name == "" || len(name) > maxNameLen {
return nil, fmt.Errorf("%w: %q", ErrInvalidName, params.Name)
}
status := params.Status
if status == "" {
status = "active"
}
if status != "active" && status != "disabled" && status != "revoked" {
return nil, fmt.Errorf("%w: %q", ErrInvalidStatus, status)
}
if params.Kind == KindCluster && len(params.PublicKey) == 0 {
return nil, fmt.Errorf("%w: clé publique requise pour un cluster", ErrInvalidKind)
}
id, err := ident.NewV7()
if err != nil {
return nil, err
}
_, err = s.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: id,
Kind: params.Kind,
Name: name,
PublicKey: params.PublicKey,
Status: status,
CreatedAt: time.Now().UnixMilli(),
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
}
return nil, err
}
return s.GetPrincipal(ctx, id)
}
func (s *Service) CreateGuest(ctx context.Context, name string) (*Principal, error) {
group, err := s.groupByName(ctx, "guests")
if err != nil {
return nil, err
}
name = strings.TrimSpace(name)
if name == "" || len(name) > maxNameLen {
return nil, fmt.Errorf("%w: %q", ErrInvalidName, name)
}
id, err := ident.NewV7()
if err != nil {
return nil, err
}
now := time.Now().UnixMilli()
err = s.withTx(ctx, func(q *database.Queries) error {
if _, err := q.CreatePrincipal(ctx, database.CreatePrincipalParams{
ID: id,
Kind: KindGuest,
Name: name,
Status: "active",
CreatedAt: now,
}); err != nil {
return err
}
_, err := q.CreateMembership(ctx, database.CreateMembershipParams{
GroupID: group.ID,
MemberID: id,
Role: RoleMember,
CreatedAt: now,
})
return err
})
if err != nil {
if isUniqueViolation(err) {
return nil, fmt.Errorf("%w: %s", ErrNameTaken, name)
}
return nil, err
}
return s.GetPrincipal(ctx, id)
}
func (s *Service) GetPrincipal(ctx context.Context, id ident.UUID) (*Principal, error) {
principal, err := s.db.Queries.GetPrincipal(ctx, id)
if err != nil {
return nil, err
}
groups, err := s.ListGroups(ctx, id)
if err != nil {
return nil, err
}
return &Principal{
ID: principal.ID,
Kind: principal.Kind,
Name: principal.Name,
Status: principal.Status,
CreatedAt: principal.CreatedAt,
Groups: groups,
}, nil
}
func validKind(kind string) bool {
switch kind {
case KindCluster, KindUser, KindGuest, KindGroup, KindSystem:
return true
default:
return false
}
}
+107
View File
@@ -0,0 +1,107 @@
package identity
import (
"context"
"errors"
"testing"
)
func TestCreatePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
created, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
Kind: KindUser,
Name: "alice",
})
if err != nil {
t.Fatalf("CreatePrincipal : %v", err)
}
if created.ID.IsZero() {
t.Fatal("identifiant vide")
}
if created.Kind != KindUser {
t.Fatalf("kind = %q, attendu %q", created.Kind, KindUser)
}
if created.Name != "alice" {
t.Fatalf("name = %q, attendu alice", created.Name)
}
if created.Status != "active" {
t.Fatalf("status = %q, attendu active", created.Status)
}
if len(created.Groups) != 0 {
t.Fatalf("groupes = %+v, attendu aucun", created.Groups)
}
}
func TestCreatePrincipalRejectsDuplicateName(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
mustCreatePrincipal(t, service, KindUser, "alice")
_, err := service.CreatePrincipal(ctx, CreatePrincipalParams{
Kind: KindUser,
Name: "alice",
})
if !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
func TestCreatePrincipalRejectsInvalidKind(t *testing.T) {
service := newTestService(t)
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: "robot",
Name: "r2d2",
})
if !errors.Is(err, ErrInvalidKind) {
t.Fatalf("erreur = %v, attendu ErrInvalidKind", err)
}
}
func TestCreatePrincipalRejectsInvalidName(t *testing.T) {
service := newTestService(t)
_, err := service.CreatePrincipal(context.Background(), CreatePrincipalParams{
Kind: KindUser,
Name: " ",
})
if !errors.Is(err, ErrInvalidName) {
t.Fatalf("erreur = %v, attendu ErrInvalidName", err)
}
}
func TestCreateGuest(t *testing.T) {
service := newTestService(t)
guest, err := service.CreateGuest(context.Background(), "jean")
if err != nil {
t.Fatalf("CreateGuest : %v", err)
}
if guest.Kind != KindGuest {
t.Fatalf("kind = %q, attendu %q", guest.Kind, KindGuest)
}
if guest.Name != "jean" {
t.Fatalf("name = %q, attendu jean", guest.Name)
}
if len(guest.Groups) != 1 || guest.Groups[0].Name != "guests" {
t.Fatalf("groupes = %+v, attendu guests", guest.Groups)
}
}
func TestCreateGuestRejectsDuplicateName(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
if _, err := service.CreateGuest(ctx, "jean"); err != nil {
t.Fatalf("CreateGuest : %v", err)
}
if _, err := service.CreateGuest(ctx, "jean"); !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
+54
View File
@@ -0,0 +1,54 @@
package identity
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"mediarr/database"
)
type Service struct {
db database.DatabaseClient
}
func NewService(db database.DatabaseClient) *Service {
return &Service{db: db}
}
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer func() {
_ = tx.Rollback()
}()
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
return err
}
return tx.Commit()
}
func isUniqueViolation(err error) bool {
return err != nil && strings.Contains(strings.ToLower(err.Error()), "unique constraint failed")
}
func (s *Service) groupByName(ctx context.Context, name string) (database.Principal, error) {
group, err := s.db.Queries.GetPrincipalByNameAndKind(ctx, database.GetPrincipalByNameAndKindParams{
Kind: KindGroup,
Name: name,
})
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return database.Principal{}, fmt.Errorf("%w: %s", ErrGroupNotFound, name)
}
return database.Principal{}, err
}
return group, nil
}