Skip to content

Modern Docker Management, Designed for Everyone

fix: only allow deleting admins if more than one exists (#2041)

Kyle Mendell78076df93362
diff --git a/backend/internal/huma/handlers/users.go b/backend/internal/huma/handlers/users.go
index 58b0d2ef8..6b8a32005 100644
--- a/backend/internal/huma/handlers/users.go
+++ b/backend/internal/huma/handlers/users.go
@@ -10,7 +10,6 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/common"
"github.com/getarcaneapp/arcane/backend/internal/models"
"github.com/getarcaneapp/arcane/backend/internal/services"
- "github.com/getarcaneapp/arcane/backend/internal/utils/mapper"
"github.com/getarcaneapp/arcane/backend/internal/utils/validation"
"github.com/getarcaneapp/arcane/types/base"
"github.com/getarcaneapp/arcane/types/user"
@@ -229,7 +228,7 @@ func (h *UserHandler) CreateUser(ctx context.Context, input *CreateUserInput) (*
return nil, huma.Error500InternalServerError((&common.UserCreationError{Err: err}).Error())
}
- out, err := mapper.MapOne[*models.User, user.User](createdUser)
+ out, err := h.userService.ToUserResponseDto(ctx, *createdUser)
if err != nil {
return nil, huma.Error500InternalServerError((&common.UserMappingError{Err: err}).Error())
}
@@ -257,7 +256,7 @@ func (h *UserHandler) GetUser(ctx context.Context, input *GetUserInput) (*GetUse
return nil, huma.Error404NotFound((&common.UserNotFoundError{}).Error())
}
- out, err := mapper.MapOne[*models.User, user.User](userModel)
+ out, err := h.userService.ToUserResponseDto(ctx, *userModel)
if err != nil {
return nil, huma.Error500InternalServerError((&common.UserMappingError{Err: err}).Error())
}
@@ -320,10 +319,16 @@ func (h *UserHandler) UpdateUser(ctx context.Context, input *UpdateUserInput) (*
updatedUser, err := h.userService.UpdateUser(ctx, userModel)
if err != nil {
+ if errors.Is(err, services.ErrCannotRemoveLastAdmin) {
+ return nil, huma.Error409Conflict(services.ErrCannotRemoveLastAdmin.Error())
+ }
+ if errors.Is(err, services.ErrUserNotFound) {
+ return nil, huma.Error404NotFound((&common.UserNotFoundError{}).Error())
+ }
return nil, huma.Error500InternalServerError((&common.UserUpdateError{Err: err}).Error())
}
- out, err := mapper.MapOne[*models.User, user.User](updatedUser)
+ out, err := h.userService.ToUserResponseDto(ctx, *updatedUser)
if err != nil {
return nil, huma.Error500InternalServerError((&common.UserMappingError{Err: err}).Error())
}
@@ -347,6 +352,12 @@ func (h *UserHandler) DeleteUser(ctx context.Context, input *DeleteUserInput) (*
}
if err := h.userService.DeleteUser(ctx, input.UserID); err != nil {
+ if errors.Is(err, services.ErrCannotRemoveLastAdmin) {
+ return nil, huma.Error409Conflict(services.ErrCannotRemoveLastAdmin.Error())
+ }
+ if errors.Is(err, services.ErrUserNotFound) {
+ return nil, huma.Error404NotFound((&common.UserNotFoundError{}).Error())
+ }
return nil, huma.Error500InternalServerError((&common.UserDeletionError{Err: err}).Error())
}
diff --git a/backend/internal/huma/handlers/users_test.go b/backend/internal/huma/handlers/users_test.go
new file mode 100644
index 000000000..290a16eb9
--- /dev/null
+++ b/backend/internal/huma/handlers/users_test.go
@@ -0,0 +1,82 @@
+package handlers
+
+import (
+ "context"
+ "net/http"
+ "testing"
+
+ "github.com/danielgtaylor/huma/v2"
+ humamw "github.com/getarcaneapp/arcane/backend/internal/huma/middleware"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/services"
+ usertypes "github.com/getarcaneapp/arcane/types/user"
+ glsqlite "github.com/glebarez/sqlite"
+ "github.com/stretchr/testify/require"
+ "gorm.io/gorm"
+
+ "github.com/getarcaneapp/arcane/backend/internal/database"
+)
+
+func setupUserHandlerTestDB(t *testing.T) *database.DB {
+ t.Helper()
+
+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, db.AutoMigrate(&models.User{}))
+
+ return &database.DB{DB: db}
+}
+
+func createHandlerTestUser(t *testing.T, svc *services.UserService, id, username string, roles models.StringSlice) *models.User {
+ t.Helper()
+
+ user := &models.User{
+ BaseModel: models.BaseModel{ID: id},
+ Username: username,
+ Roles: roles,
+ }
+
+ created, err := svc.CreateUser(context.Background(), user)
+ require.NoError(t, err)
+
+ return created
+}
+
+func adminContext() context.Context {
+ return context.WithValue(context.Background(), humamw.ContextKeyUserIsAdmin, true)
+}
+
+func TestDeleteUserReturnsConflictForLastAdmin(t *testing.T) {
+ db := setupUserHandlerTestDB(t)
+ userSvc := services.NewUserService(db)
+ handler := &UserHandler{userService: userSvc}
+ admin := createHandlerTestUser(t, userSvc, "admin-1", "arcane", models.StringSlice{"admin"})
+
+ _, err := handler.DeleteUser(adminContext(), &DeleteUserInput{UserID: admin.ID})
+ require.Error(t, err)
+
+ var statusErr huma.StatusError
+ require.ErrorAs(t, err, &statusErr)
+ require.Equal(t, http.StatusConflict, statusErr.GetStatus())
+ require.Contains(t, statusErr.Error(), services.ErrCannotRemoveLastAdmin.Error())
+}
+
+func TestUpdateUserReturnsConflictWhenRemovingLastAdminRole(t *testing.T) {
+ db := setupUserHandlerTestDB(t)
+ userSvc := services.NewUserService(db)
+ handler := &UserHandler{userService: userSvc}
+ admin := createHandlerTestUser(t, userSvc, "admin-1", "arcane", models.StringSlice{"ADMIN"})
+
+ _, err := handler.UpdateUser(adminContext(), &UpdateUserInput{
+ UserID: admin.ID,
+ Body: usertypes.UpdateUser{
+ Roles: []string{"user"},
+ },
+ })
+ require.Error(t, err)
+
+ var statusErr huma.StatusError
+ require.ErrorAs(t, err, &statusErr)
+ require.Equal(t, http.StatusConflict, statusErr.GetStatus())
+ require.Contains(t, statusErr.Error(), services.ErrCannotRemoveLastAdmin.Error())
+}
diff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.go
index c24a6c76c..ccc3d3623 100644
--- a/backend/internal/services/user_service.go
+++ b/backend/internal/services/user_service.go
@@ -44,6 +44,8 @@ type UserService struct {
argon2Params *Argon2Params
}
+var ErrCannotRemoveLastAdmin = errors.New("cannot remove the last admin user")
+
func NewUserService(db *database.DB) *UserService {
return &UserService{
db: db,
@@ -188,6 +190,27 @@ func (s *UserService) GetUserByEmail(ctx context.Context, email string) (*models
func (s *UserService) UpdateUser(ctx context.Context, user *models.User) (*models.User, error) {
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.User
+ if err := tx.
+ Clauses(clause.Locking{Strength: "UPDATE"}).
+ Where("id = ?", user.ID).
+ First(&existing).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return ErrUserNotFound
+ }
+ return fmt.Errorf("failed to load user: %w", err)
+ }
+
+ if userHasRoleInternal(existing.Roles, "admin") && !userHasRoleInternal(user.Roles, "admin") {
+ remainingAdmins, err := s.remainingAdminCountExcludingUserInternal(tx, user.ID)
+ if err != nil {
+ return err
+ }
+ if remainingAdmins == 0 {
+ return ErrCannotRemoveLastAdmin
+ }
+ }
+
if err := tx.Save(user).Error; err != nil {
return fmt.Errorf("failed to update user: %w", err)
}
@@ -292,6 +315,27 @@ func (s *UserService) CreateDefaultAdmin(ctx context.Context) error {
func (s *UserService) DeleteUser(ctx context.Context, id string) error {
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ var existing models.User
+ if err := tx.
+ Clauses(clause.Locking{Strength: "UPDATE"}).
+ Where("id = ?", id).
+ First(&existing).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return ErrUserNotFound
+ }
+ return fmt.Errorf("failed to load user: %w", err)
+ }
+
+ if userHasRoleInternal(existing.Roles, "admin") {
+ remainingAdmins, err := s.remainingAdminCountExcludingUserInternal(tx, id)
+ if err != nil {
+ return err
+ }
+ if remainingAdmins == 0 {
+ return ErrCannotRemoveLastAdmin
+ }
+ }
+
if err := tx.Delete(&models.User{}, "id = ?", id).Error; err != nil {
return fmt.Errorf("failed to delete user: %w", err)
}
@@ -340,25 +384,54 @@ func (s *UserService) ListUsersPaginated(ctx context.Context, params pagination.
return nil, pagination.Response{}, fmt.Errorf("failed to paginate users: %w", err)
}
+ result, err := s.toUserResponseDtosInternal(ctx, users)
+ if err != nil {
+ return nil, pagination.Response{}, err
+ }
+
+ return result, paginationResp, nil
+}
+
+func (s *UserService) ToUserResponseDto(ctx context.Context, u models.User) (user.User, error) {
+ if !userHasRoleInternal(u.Roles, "admin") {
+ return toUserResponseDtoInternal(u, 0), nil
+ }
+
+ adminCount, err := s.adminUserCountInternal(ctx)
+ if err != nil {
+ return user.User{}, err
+ }
+
+ return toUserResponseDtoInternal(u, adminCount), nil
+}
+
+func (s *UserService) toUserResponseDtosInternal(ctx context.Context, users []models.User) ([]user.User, error) {
+ adminCount, err := s.adminUserCountInternal(ctx)
+ if err != nil {
+ return nil, err
+ }
+
result := make([]user.User, len(users))
for i, u := range users {
- result[i] = toUserResponseDto(u)
+ result[i] = toUserResponseDtoInternal(u, adminCount)
}
- return result, paginationResp, nil
+ return result, nil
}
-func toUserResponseDto(u models.User) user.User {
+func toUserResponseDtoInternal(u models.User, adminCount int) user.User {
return user.User{
- ID: u.ID,
- Username: u.Username,
- DisplayName: u.DisplayName,
- Email: u.Email,
- Roles: u.Roles,
- OidcSubjectId: u.OidcSubjectId,
- Locale: u.Locale,
- CreatedAt: u.CreatedAt.Format("2006-01-02T15:04:05.999999Z"),
- UpdatedAt: u.UpdatedAt.Format("2006-01-02T15:04:05.999999Z"),
+ ID: u.ID,
+ Username: u.Username,
+ DisplayName: u.DisplayName,
+ Email: u.Email,
+ Roles: u.Roles,
+ CanDelete: !userHasRoleInternal(u.Roles, "admin") || adminCount > 1,
+ OidcSubjectId: u.OidcSubjectId,
+ Locale: u.Locale,
+ RequiresPasswordChange: u.RequiresPasswordChange,
+ CreatedAt: u.CreatedAt.Format("2006-01-02T15:04:05.999999Z"),
+ UpdatedAt: u.UpdatedAt.Format("2006-01-02T15:04:05.999999Z"),
}
}
@@ -376,3 +449,49 @@ func (s *UserService) getUserInternal(ctx context.Context, userID string, tx *go
Error
return &user, err
}
+
+func (s *UserService) remainingAdminCountExcludingUserInternal(tx *gorm.DB, excludedUserID string) (int, error) {
+ var count int64
+ if err := s.adminUsersScopeInternal(tx.Model(&models.User{}).Where("id <> ?", excludedUserID)).Count(&count).Error; err != nil {
+ return 0, fmt.Errorf("failed to count remaining admin users: %w", err)
+ }
+
+ return int(count), nil
+}
+
+func userHasRoleInternal(roles models.StringSlice, role string) bool {
+ for _, currentRole := range roles {
+ if strings.EqualFold(currentRole, role) {
+ return true
+ }
+ }
+
+ return false
+}
+
+func (s *UserService) adminUserCountInternal(ctx context.Context) (int, error) {
+ var count int64
+ if err := s.adminUsersScopeInternal(s.db.WithContext(ctx).Model(&models.User{})).Count(&count).Error; err != nil {
+ return 0, fmt.Errorf("failed to count admin users: %w", err)
+ }
+
+ return int(count), nil
+}
+
+func (s *UserService) adminUsersScopeInternal(query *gorm.DB) *gorm.DB {
+ switch s.db.Name() {
+ case "sqlite":
+ return query.Where(
+ "EXISTS (SELECT 1 FROM json_each(users.roles) WHERE lower(json_each.value) = ?)",
+ "admin",
+ )
+ case "postgres":
+ return query.Where(
+ "EXISTS (SELECT 1 FROM jsonb_array_elements_text(users.roles::jsonb) AS role WHERE lower(role) = ?)",
+ "admin",
+ )
+ default:
+ slog.Warn("Using LIKE-based admin role query fallback for unsupported database dialect", "dialect", s.db.Name())
+ return query.Where("LOWER(roles) LIKE ?", `%\"admin\"%`)
+ }
+}
diff --git a/backend/internal/services/user_service_test.go b/backend/internal/services/user_service_test.go
new file mode 100644
index 000000000..e56fc8f1d
--- /dev/null
+++ b/backend/internal/services/user_service_test.go
@@ -0,0 +1,130 @@
+package services
+
+import (
+ "context"
+ "testing"
+
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
+ "github.com/stretchr/testify/require"
+)
+
+func createTestUser(t *testing.T, svc *UserService, id, username string, roles models.StringSlice) *models.User {
+ t.Helper()
+
+ user := &models.User{
+ BaseModel: models.BaseModel{ID: id},
+ Username: username,
+ Roles: roles,
+ }
+
+ created, err := svc.CreateUser(context.Background(), user)
+ require.NoError(t, err)
+
+ return created
+}
+
+func TestDeleteUserRejectsDeletingOnlyAdmin(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ admin := createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"Admin"})
+
+ err := svc.DeleteUser(ctx, admin.ID)
+ require.ErrorIs(t, err, ErrCannotRemoveLastAdmin)
+
+ stillThere, err := svc.GetUserByID(ctx, admin.ID)
+ require.NoError(t, err)
+ require.Equal(t, admin.ID, stillThere.ID)
+}
+
+func TestDeleteUserAllowsDeletingNonAdmin(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"admin"})
+ nonAdmin := createTestUser(t, svc, "user-1", "user", models.StringSlice{"user"})
+
+ err := svc.DeleteUser(ctx, nonAdmin.ID)
+ require.NoError(t, err)
+
+ _, err = svc.GetUserByID(ctx, nonAdmin.ID)
+ require.ErrorIs(t, err, ErrUserNotFound)
+}
+
+func TestDeleteUserAllowsDeletingAdminWhenAnotherAdminExists(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ adminToDelete := createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"Admin"})
+ createTestUser(t, svc, "admin-2", "backup", models.StringSlice{"admin"})
+
+ err := svc.DeleteUser(ctx, adminToDelete.ID)
+ require.NoError(t, err)
+
+ _, err = svc.GetUserByID(ctx, adminToDelete.ID)
+ require.ErrorIs(t, err, ErrUserNotFound)
+}
+
+func TestUpdateUserRejectsRemovingAdminFromOnlyAdmin(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ admin := createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"ADMIN"})
+ admin.Roles = models.StringSlice{"user"}
+
+ _, err := svc.UpdateUser(ctx, admin)
+ require.ErrorIs(t, err, ErrCannotRemoveLastAdmin)
+
+ persisted, err := svc.GetUserByID(ctx, admin.ID)
+ require.NoError(t, err)
+ require.Equal(t, models.StringSlice{"ADMIN"}, persisted.Roles)
+}
+
+func TestUpdateUserAllowsRemovingAdminWhenAnotherAdminExists(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ admin := createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"admin"})
+ createTestUser(t, svc, "admin-2", "backup", models.StringSlice{"ADMIN"})
+
+ admin.Roles = models.StringSlice{"user"}
+
+ updated, err := svc.UpdateUser(ctx, admin)
+ require.NoError(t, err)
+ require.Equal(t, models.StringSlice{"user"}, updated.Roles)
+
+ persisted, err := svc.GetUserByID(ctx, admin.ID)
+ require.NoError(t, err)
+ require.Equal(t, models.StringSlice{"user"}, persisted.Roles)
+}
+
+func TestListUsersPaginatedSetsCanDeleteFromGlobalAdminCount(t *testing.T) {
+ db := setupAuthServiceTestDB(t)
+ svc := NewUserService(db)
+ ctx := context.Background()
+
+ lastAdmin := createTestUser(t, svc, "admin-1", "arcane", models.StringSlice{"admin"})
+ nonAdmin := createTestUser(t, svc, "user-1", "user", models.StringSlice{"user"})
+
+ users, _, err := svc.ListUsersPaginated(ctx, pagination.QueryParams{
+ PaginationParams: pagination.PaginationParams{Start: 0, Limit: 20},
+ SortParams: pagination.SortParams{Sort: "Username", Order: pagination.SortOrder("asc")},
+ Filters: map[string]string{},
+ })
+ require.NoError(t, err)
+ require.Len(t, users, 2)
+
+ canDeleteByID := make(map[string]bool, len(users))
+ for _, user := range users {
+ canDeleteByID[user.ID] = user.CanDelete
+ }
+
+ require.False(t, canDeleteByID[lastAdmin.ID])
+ require.True(t, canDeleteByID[nonAdmin.ID])
+}
diff --git a/frontend/src/lib/types/user.type.ts b/frontend/src/lib/types/user.type.ts
index dc492b928..5d75bf314 100644
--- a/frontend/src/lib/types/user.type.ts
+++ b/frontend/src/lib/types/user.type.ts
@@ -7,6 +7,7 @@ export type User = {
displayName?: string;
email?: string;
roles: string[];
+ canDelete?: boolean;
createdAt: string;
lastLogin?: string;
updatedAt?: string;
diff --git a/frontend/src/routes/(app)/settings/users/user-table.svelte b/frontend/src/routes/(app)/settings/users/user-table.svelte
index 9defcf161..16a05e13f 100644
--- a/frontend/src/routes/(app)/settings/users/user-table.svelte
+++ b/frontend/src/routes/(app)/settings/users/user-table.svelte
@@ -33,8 +33,18 @@
removing: false
});
+ function canDeleteUser(user: User) {
+ return user.canDelete !== false;
+ }
+
+ const selectedUsers = $derived.by(() =>
+ (selectedIds ?? []).map((id) => users.data.find((user) => user.id === id)).filter((user): user is User => Boolean(user))
+ );
+
+ const hasProtectedSelection = $derived.by(() => selectedUsers.some((user) => !canDeleteUser(user)));
+
async function handleDeleteSelected() {
- if (selectedIds.length === 0) return;
+ if (selectedIds.length === 0 || hasProtectedSelection) return;
openConfirmDialog({
title: m.users_delete_selected_title({ count: selectedIds.length }),
@@ -82,8 +92,10 @@
});
}
- async function handleDeleteUser(userId: string, username: string) {
- const safeName = username?.trim() || m.common_unknown();
+ async function handleDeleteUser(user: User) {
+ if (!canDeleteUser(user)) return;
+
+ const safeName = user.username?.trim() || m.common_unknown();
openConfirmDialog({
title: m.users_delete_user_title({ username: safeName }),
message: m.users_delete_user_message({ username: safeName }),
@@ -93,7 +105,7 @@
action: async () => {
isLoading.removing = true;
handleApiResultWithCallbacks({
- result: await tryCatch(userService.delete(userId)),
+ result: await tryCatch(userService.delete(user.id)),
message: m.users_delete_user_failed({ username: safeName }),
setLoadingState: (value) => (isLoading.removing = value),
onSuccess: async () => {
@@ -136,7 +148,7 @@
action: 'remove',
onClick: handleDeleteSelected,
loading: isLoading.removing,
- disabled: isLoading.removing,
+ disabled: isLoading.removing || hasProtectedSelection,
icon: TrashIcon
}
]);
@@ -209,7 +221,11 @@
<DropdownMenu.Separator />
{/if}
- <DropdownMenu.Item variant="destructive" onclick={() => handleDeleteUser(item.id, item.username)}>
+ <DropdownMenu.Item
+ variant="destructive"
+ disabled={!canDeleteUser(item) || isLoading.removing}
+ onclick={() => handleDeleteUser(item)}
+ >
<TrashIcon class="size-4" />
{m.common_delete()}
</DropdownMenu.Item>
diff --git a/types/user/user.go b/types/user/user.go
index 39a66e2f8..b4ae1811f 100644
--- a/types/user/user.go
+++ b/types/user/user.go
@@ -27,6 +27,7 @@ type User struct {
DisplayName *string `json:"displayName,omitempty" doc:"Display name of the user" example:"John Doe"`
Email *string `json:"email,omitempty" doc:"Email address of the user" example:"[email protected]"`
Roles []string `json:"roles" doc:"Roles assigned to the user" example:"[\"user\", \"admin\"]"`
+ CanDelete bool `json:"canDelete" doc:"Whether the user can currently be deleted"`
OidcSubjectId *string `json:"oidcSubjectId,omitempty" doc:"OIDC subject identifier for SSO users"`
Locale *string `json:"locale,omitempty" doc:"Locale preference of the user" example:"en-US"`
CreatedAt string `json:"createdAt,omitempty" doc:"Date and time when the user was created"`