mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
253 lines
6.1 KiB
Go
253 lines
6.1 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"log/slog"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// ErrUserHasSpaceMembership blocks account deletion until its Space lifecycle
|
|
// has been resolved explicitly.
|
|
var ErrUserHasSpaceMembership = stderrors.New("user still has space memberships")
|
|
|
|
// ErrLastInstanceAdmin indicates that a user mutation would leave the instance
|
|
// without an active administrator.
|
|
var ErrLastInstanceAdmin = stderrors.New("cannot remove the last instance admin")
|
|
|
|
// RemovesInstanceAdmin reports whether the update can take the user out of
|
|
// the set of active instance administrators.
|
|
func (update *UpdateUser) RemovesInstanceAdmin() bool {
|
|
return (update.RowStatus != nil && *update.RowStatus != Normal) || (update.Role != nil && *update.Role != RoleAdmin)
|
|
}
|
|
|
|
// Role is the type of a role.
|
|
type Role string
|
|
|
|
const (
|
|
// RoleAdmin is the ADMIN role.
|
|
RoleAdmin Role = "ADMIN"
|
|
// RoleUser is the USER role.
|
|
RoleUser Role = "USER"
|
|
)
|
|
|
|
func (e Role) String() string {
|
|
switch e {
|
|
case RoleAdmin:
|
|
return "ADMIN"
|
|
default:
|
|
return "USER"
|
|
}
|
|
}
|
|
|
|
type User struct {
|
|
ID int32
|
|
|
|
// Standard fields
|
|
RowStatus RowStatus
|
|
CreatedTs int64
|
|
UpdatedTs int64
|
|
|
|
// Domain specific fields
|
|
Username string
|
|
Role Role
|
|
Email string
|
|
Nickname string
|
|
PasswordHash string
|
|
AvatarURL string
|
|
Description string
|
|
}
|
|
|
|
type UpdateUser struct {
|
|
ID int32
|
|
|
|
UpdatedTs *int64
|
|
RowStatus *RowStatus
|
|
Username *string
|
|
Role *Role
|
|
Email *string
|
|
Nickname *string
|
|
Password *string
|
|
AvatarURL *string
|
|
PasswordHash *string
|
|
Description *string
|
|
}
|
|
|
|
type FindUser struct {
|
|
ID *int32
|
|
IDList []int32
|
|
|
|
UsernameList []string
|
|
|
|
RowStatus *RowStatus
|
|
Username *string
|
|
Role *Role
|
|
Email *string
|
|
Nickname *string
|
|
Search *string
|
|
|
|
// Domain specific fields
|
|
Filters []string
|
|
|
|
// The maximum number of users to return.
|
|
Limit *int
|
|
// The offset of the returned users.
|
|
Offset *int
|
|
}
|
|
|
|
type DeleteUser struct {
|
|
ID int32
|
|
}
|
|
|
|
func userCacheKey(userID int32) string {
|
|
return strconv.Itoa(int(userID))
|
|
}
|
|
|
|
// normalizeUserEmail canonicalizes the address on a user about to be written.
|
|
// The API layer validates first; this is the store's own guard so that seed
|
|
// data, tests, and any future caller cannot bypass the canonical form.
|
|
func normalizeUserEmail(email string) (string, error) {
|
|
normalized, err := NormalizeEmail(email)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "invalid email")
|
|
}
|
|
return normalized, nil
|
|
}
|
|
|
|
func (s *Store) CreateUser(ctx context.Context, create *User) (*User, error) {
|
|
email, err := normalizeUserEmail(create.Email)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
create.Email = email
|
|
user, err := s.driver.CreateUser(ctx, create)
|
|
if err != nil {
|
|
if uniqueErr := classifyUserUniqueViolation(err); uniqueErr != nil {
|
|
return nil, uniqueErr
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
s.userCache.Set(ctx, userCacheKey(user.ID), user)
|
|
return user, nil
|
|
}
|
|
|
|
// CreateUserIfNoUsers creates a user only when the instance has no users.
|
|
// The in-process lock prevents concurrent first-user setup requests from
|
|
// creating multiple admins in the same server process.
|
|
func (s *Store) CreateUserIfNoUsers(ctx context.Context, create *User) (*User, bool, error) {
|
|
s.userCreateMu.Lock()
|
|
defer s.userCreateMu.Unlock()
|
|
|
|
limitOne := 1
|
|
users, err := s.driver.ListUsers(ctx, &FindUser{Limit: &limitOne})
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
if len(users) > 0 {
|
|
return nil, false, nil
|
|
}
|
|
|
|
email, err := normalizeUserEmail(create.Email)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
create.Email = email
|
|
user, err := s.driver.CreateUser(ctx, create)
|
|
if err != nil {
|
|
if uniqueErr := classifyUserUniqueViolation(err); uniqueErr != nil {
|
|
return nil, false, uniqueErr
|
|
}
|
|
return nil, false, err
|
|
}
|
|
s.userCache.Set(ctx, userCacheKey(user.ID), user)
|
|
return user, true, nil
|
|
}
|
|
|
|
func (s *Store) UpdateUser(ctx context.Context, update *UpdateUser) (*User, error) {
|
|
if update.Email != nil {
|
|
email, err := normalizeUserEmail(*update.Email)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
update.Email = &email
|
|
}
|
|
user, err := s.driver.UpdateUser(ctx, update)
|
|
if err != nil {
|
|
if uniqueErr := classifyUserUniqueViolation(err); uniqueErr != nil {
|
|
return nil, uniqueErr
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
s.userCache.Set(ctx, userCacheKey(user.ID), user)
|
|
return user, nil
|
|
}
|
|
|
|
func (s *Store) ListUsers(ctx context.Context, find *FindUser) ([]*User, error) {
|
|
if find.Email != nil {
|
|
// Lookups compare against the canonical stored form. "No address" is
|
|
// stored as NULL and never matches, so an empty lookup returns nothing
|
|
// rather than every user without an address.
|
|
email := strings.ToLower(strings.TrimSpace(*find.Email))
|
|
if email == "" {
|
|
return []*User{}, nil
|
|
}
|
|
find.Email = &email
|
|
}
|
|
list, err := s.driver.ListUsers(ctx, find)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, user := range list {
|
|
s.userCache.Set(ctx, userCacheKey(user.ID), user)
|
|
}
|
|
return list, nil
|
|
}
|
|
|
|
func (s *Store) GetUser(ctx context.Context, find *FindUser) (*User, error) {
|
|
if find.ID != nil {
|
|
if cache, ok := s.userCache.Get(ctx, userCacheKey(*find.ID)); ok {
|
|
user, ok := cache.(*User)
|
|
if ok {
|
|
return user, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
list, err := s.ListUsers(ctx, find)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(list) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
user := list[0]
|
|
s.userCache.Set(ctx, userCacheKey(user.ID), user)
|
|
return user, nil
|
|
}
|
|
|
|
// DeleteUser removes a user and returns cache invalidation state. Deleting an
|
|
// already-missing user is idempotent and returns an empty result.
|
|
func (s *Store) DeleteUser(ctx context.Context, delete *DeleteUser) (*DeleteUserResult, error) {
|
|
result, err := s.driver.DeleteUser(ctx, delete)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if result == nil {
|
|
return nil, errors.New("unexpected nil delete user result")
|
|
}
|
|
s.deleteUserCache(ctx, delete.ID, result)
|
|
// The user is already gone, so a failure here only leaves an ID that
|
|
// never matches anyone.
|
|
if err := s.RemoveUserFromUsageLimits(ctx, delete.ID); err != nil {
|
|
slog.Warn("failed to remove deleted user from usage limits", slog.Int("userID", int(delete.ID)), slog.String("error", err.Error()))
|
|
}
|
|
return result, nil
|
|
}
|