Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
fix(auth): provision SSO users atomically (#6114)
Johnny019f4f9adcfc
diff --git a/server/router/api/v1/auth_service.go b/server/router/api/v1/auth_service.goindex 073131643..34445b3d1 100644--- a/server/router/api/v1/auth_service.go+++ b/server/router/api/v1/auth_service.go@@ -110,11 +110,11 @@ func (s *APIV1Service) SignIn(ctx context.Context, request *v1pb.SignInRequest)// resolveSSOUser resolves a local user from an external-identity subject, creating the// linkage record (and a new local user if necessary) when first login is allowed.//-// Lookup goes through the user_identity table so that userInfo.Identifier is never used-// as the local username key. On the miss path, a local user is created with a-// UUID-backed local username (see deriveSSOUsername) and the (provider, extern_uid)-// linkage is inserted in the same flow. When currentUser is provided by a caller-// outside AuthService.SignIn, the lookup miss path binds the external identity to-// that existing user instead. If the linkage insert loses a race on the unique-// (provider, extern_uid) constraint, the winning linkage's user is loaded and-// checked against the current user.+// Lookup goes through the user_identity table instead of using userInfo.Identifier+// as the local lookup key. On the miss path, a local user is created with the+// identifier as its username when valid and available, or a UUID fallback+// otherwise, and the (provider, extern_uid) linkage is committed atomically with+// the user. When currentUser is provided by a caller outside AuthService.SignIn,+// the lookup miss path binds the external identity to that existing user instead.+// Concurrent first logins reconcile uniqueness conflicts by loading the linkage+// winner.diff --git a/server/router/api/v1/auth_service_sso.go b/server/router/api/v1/auth_service_sso.goindex 57cc9e362..0fd153315 100644--- a/server/router/api/v1/auth_service_sso.go+++ b/server/router/api/v1/auth_service_sso.go@@ -5,6 +5,7 @@ import ("regexp""strings"+ "github.com/pkg/errors""golang.org/x/crypto/bcrypt""google.golang.org/grpc/codes""google.golang.org/grpc/status"@@ -19,6 +20,11 @@ import (func (s *APIV1Service) resolveSSOUser(ctx context.Context, currentUser *store.User, identityProvider *storepb.IdentityProvider, userInfo *idp.IdentityProviderUserInfo) (*store.User, error) {provider := identityProvider.UidexternUID := userInfo.Identifier+ // Defense in depth: an empty subject must never key a lookup or provision an+ // account, regardless of whether the IdP layer already rejected it.+ if externUID == "" {+ return nil, status.Errorf(codes.InvalidArgument, "identity provider returned an empty subject identifier")+ }user, err := s.getLinkedSSOUser(ctx, provider, externUID)if err != nil {@@ -52,53 +58,86 @@ func (s *APIV1Service) resolveSSOUser(ctx context.Context, currentUser *store.Usif err != nil {return nil, status.Errorf(codes.Internal, "failed to generate password hash, error: %v", err)}- username, err := deriveSSOUsername()- if err != nil {- return nil, status.Errorf(codes.Internal, "failed to derive username, error: %v", err)- }- user, err = s.Store.CreateUser(ctx, &store.User{- Username: username,- Role: store.RoleUser,- Nickname: userInfo.DisplayName,- Email: userInfo.Email,- AvatarURL: userInfo.AvatarURL,- PasswordHash: string(passwordHash),- })+ user, err = s.createSSOUser(ctx, userInfo, string(passwordHash), provider, externUID)if err != nil {return nil, status.Errorf(codes.Internal, "failed to create user, error: %v", err)}+ return user, nil+}- if _, err := s.Store.CreateUserIdentity(ctx, &store.UserIdentity{- UserID: user.ID,- Provider: provider,- ExternUID: externUID,- }); err != nil {- // Best-effort cleanup: the provisional user row has no linkage and should not remain.- _, _ = s.Store.DeleteUser(ctx, &store.DeleteUser{ID: user.ID})- if isUniqueConstraintViolation(err) {- // Concurrent first login won the race; load the winning linkage's user.- winner, getErr := s.Store.GetUserIdentity(ctx, &store.FindUserIdentity{- Provider: &provider,- ExternUID: &externUID,- })- if getErr != nil {- return nil, status.Errorf(codes.Internal, "failed to reload user identity after race, error: %v", getErr)- }- if winner == nil {- return nil, status.Errorf(codes.Internal, "user identity conflict reported but no winning row found")- }- winnerUser, getErr := s.Store.GetUser(ctx, &store.FindUser{ID: &winner.UserID})- if getErr != nil {- return nil, status.Errorf(codes.Internal, "failed to get user after race, error: %v", getErr)- }- if winnerUser == nil {- return nil, status.Errorf(codes.Internal, "linked user %d not found after race", winner.UserID)- }- return winnerUser, nil+// createSSOUser prefers the mapped external identifier as the initial local+// username when it satisfies the local username rules and is not a reserved+// name. A database uniqueness conflict falls back to a generated UUID instead of+// linking the SSO identity to the existing same-named account. User and identity+// creation are committed atomically so a concurrent UUID fallback cannot win+// after another request has claimed the preferred username.+//+// tryUsername returns a non-nil user when the identity is resolved (either newly+// created or reconciled to a concurrent winner) and (nil, nil) when the username+// is already taken and the caller should retry with a different one.+func (s *APIV1Service) createSSOUser(+ ctx context.Context,+ userInfo *idp.IdentityProviderUserInfo,+ passwordHash string,+ provider string,+ externUID string,+) (*store.User, error) {+ tryUsername := func(username string) (*store.User, error) {+ user, err := s.Store.CreateUserWithIdentity(ctx, &store.User{+ Username: username,+ Role: store.RoleUser,+ Nickname: userInfo.DisplayName,+ Email: userInfo.Email,+ AvatarURL: userInfo.AvatarURL,+ PasswordHash: passwordHash,+ }, &store.UserIdentity{+ Provider: provider,+ ExternUID: externUID,+ })+ if err == nil {+ return user, nil}- return nil, status.Errorf(codes.Internal, "failed to create user identity, error: %v", err)+ if !isUniqueConstraintViolation(err) {+ return nil, err+ }++ // A unique violation is either the (provider, extern_uid) linkage (a+ // concurrent first login won — reconcile to its user) or the username (in+ // use by another account — signal a retry with a fresh username). Supported+ // databases only report the competing unique-key violation after the winner+ // commits, so its identity linkage is visible to this follow-up read.+ return s.getLinkedSSOUser(ctx, provider, externUID)}- return user, nil++ // Only adopt the external identifier as the local username when it is a valid,+ // non-reserved name; otherwise an attacker-influenceable identifier could+ // squat a privileged or system handle. Reserved and invalid names fall back to+ // an opaque UUID.+ if err := validateWritableUsername(userInfo.Identifier); err == nil && !isReservedUsername(userInfo.Identifier) {+ user, err := tryUsername(userInfo.Identifier)+ if err != nil {+ return nil, err+ }+ if user != nil {+ return user, nil+ }+ }++ for range ssoUsernameFallbackAttempts {+ username, err := deriveSSOUsername()+ if err != nil {+ return nil, err+ }+ user, err := tryUsername(username)+ if err != nil {+ return nil, err+ }+ if user != nil {+ return user, nil+ }+ }++ return nil, errors.Errorf("exhausted %d UUID username attempts", ssoUsernameFallbackAttempts)}func (s *APIV1Service) resolveSSOIdentity(ctx context.Context, idpName, code, redirectURI, codeVerifier string) (*storepb.IdentityProvider, *idp.IdentityProviderUserInfo, error) {diff --git a/server/router/api/v1/sso_username.go b/server/router/api/v1/sso_username.goindex 0c40b92ec..038a43d24 100644--- a/server/router/api/v1/sso_username.go+++ b/server/router/api/v1/sso_username.go@@ -1,16 +1,41 @@package v1import (+ "strings"+"github.com/pkg/errors""github.com/usememos/memos/internal/util")+const ssoUsernameFallbackAttempts = 5++// reservedUsernames are names that must never be auto-assigned from an external+// identity provider. A user-influenceable identifier (e.g. an OIDC+// preferred_username) claiming one of these on first login would squat a+// privileged or system-suggestive handle, so it falls back to a UUID instead.+var reservedUsernames = map[string]struct{}{+ "admin": {},+ "administrator": {},+ "api": {},+ "memos": {},+ "root": {},+ "support": {},+ "system": {},+}++// isReservedUsername reports whether username is reserved. The comparison is+// case-insensitive because some backends fold case on the username unique index.+func isReservedUsername(username string) bool {+ _, ok := reservedUsernames[strings.ToLower(strings.TrimSpace(username))]+ return ok+}+// deriveSSOUsername produces the local username for a new SSO-created user.//-// The current policy is to use a standard UUID string directly. This keeps the-// username independent of IdP profile fields and avoids availability probes or-// retry loops around concurrent first-time logins.+// UUID usernames are the fallback when the IdP identifier cannot safely be used+// as the local username, such as when it is invalid or already belongs to+// another local account.func deriveSSOUsername() (string, error) {username := util.GenUUID()if err := validateWritableUsername(username); err != nil {diff --git a/server/router/api/v1/test/auth_service_sso_username_test.go b/server/router/api/v1/test/auth_service_sso_username_test.gonew file mode 100644index 000000000..64331eb46--- /dev/null+++ b/server/router/api/v1/test/auth_service_sso_username_test.go@@ -0,0 +1,383 @@+package test++import (+ "context"+ "strings"+ "sync"+ "testing"++ "github.com/google/uuid"+ "github.com/stretchr/testify/require"+ "google.golang.org/grpc/codes"+ "google.golang.org/grpc/status"++ v1pb "github.com/usememos/memos/proto/gen/api/v1"+ storepb "github.com/usememos/memos/proto/gen/store"+ apiv1 "github.com/usememos/memos/server/router/api/v1"+ "github.com/usememos/memos/store"+)++func TestSSOSignInUsesValidIdentifierAsUsername(t *testing.T) {+ tests := []struct {+ name string+ identifier string+ }{+ {name: "single character", identifier: "a"},+ {name: "common username", identifier: "alice"},+ {name: "uppercase and hyphens", identifier: "Alice-01"},+ {name: "maximum length", identifier: strings.Repeat("a", 36)},+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "valid-code", "valid-token", map[string]any{+ "sub": test.identifier,+ "name": "Different Display Name",+ "email": "[email protected]",+ })+ defer mockIDP.Close()++ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "valid-identifier")+ response, err := signInWithTestingSSO(ctx, ts, idpName, "valid-code")+ require.NoError(t, err)+ require.Equal(t, test.identifier, response.User.Username)++ assertSingleSSOLink(ctx, t, ts, "valid-identifier", test.identifier, response.User.Username)+ })+ }+}++func TestSSOSignInFallsBackForInvalidIdentifier(t *testing.T) {+ tests := []struct {+ name string+ identifier string+ }{+ {name: "numeric", identifier: "12345"},+ {name: "email", identifier: "[email protected]"},+ {name: "underscore", identifier: "alice_example"},+ {name: "leading hyphen", identifier: "-alice"},+ {name: "trailing hyphen", identifier: "alice-"},+ {name: "surrounding whitespace", identifier: " alice "},+ {name: "too long", identifier: strings.Repeat("a", 37)},+ {name: "non ASCII", identifier: "爱丽丝"},+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "invalid-code", "invalid-token", map[string]any{+ "sub": test.identifier,+ "name": "Alice Example",+ })+ defer mockIDP.Close()++ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "invalid-identifier")+ response, err := signInWithTestingSSO(ctx, ts, idpName, "invalid-code")+ require.NoError(t, err)+ require.NotEqual(t, test.identifier, response.User.Username)+ _, err = uuid.Parse(response.User.Username)+ require.NoError(t, err, "fallback username must be a UUID")++ assertSingleSSOLink(ctx, t, ts, "invalid-identifier", test.identifier, response.User.Username)+ })+ }+}++func TestSSOSignInDoesNotTakeOverExistingUsername(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ existingUser, err := ts.CreateRegularUser(ctx, "alice")+ require.NoError(t, err)++ mockIDP := newMockOAuthServer(t, "collision-code", "collision-token", map[string]any{+ "sub": "alice",+ "name": "SSO Alice",+ "email": "[email protected]",+ })+ defer mockIDP.Close()++ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "username-collision")+ response, err := signInWithTestingSSO(ctx, ts, idpName, "collision-code")+ require.NoError(t, err)+ require.NotEqual(t, existingUser.Username, response.User.Username)+ _, err = uuid.Parse(response.User.Username)+ require.NoError(t, err)+ repeated, err := signInWithTestingSSO(ctx, ts, idpName, "collision-code")+ require.NoError(t, err)+ require.Equal(t, response.User.Name, repeated.User.Name)++ stillExisting, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &existingUser.ID})+ require.NoError(t, err)+ require.Equal(t, "alice", stillExisting.Username)++ users, err := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, err)+ require.Len(t, users, 2)+ assertSingleSSOLink(ctx, t, ts, "username-collision", "alice", response.User.Username)+}++func TestSSOSignInDoesNotAdoptReservedUsername(t *testing.T) {+ for _, identifier := range []string{"admin", "Admin", "support", "root"} {+ t.Run(identifier, func(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "reserved-code", "reserved-token", map[string]any{"sub": identifier})+ defer mockIDP.Close()++ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "reserved-provider")+ response, err := signInWithTestingSSO(ctx, ts, idpName, "reserved-code")+ require.NoError(t, err)+ require.NotEqual(t, identifier, response.User.Username)+ _, err = uuid.Parse(response.User.Username)+ require.NoError(t, err, "reserved identifier must fall back to a UUID")+ })+ }+}++func TestSSOSignInReusesLinkedUser(t *testing.T) {+ tests := []struct {+ name string+ identifier string+ }{+ {name: "preferred username", identifier: "alice"},+ {name: "UUID fallback", identifier: "[email protected]"},+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "repeat-code", "repeat-token", map[string]any{+ "sub": test.identifier,+ "name": "Alice Example",+ })+ defer mockIDP.Close()++ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "repeat-provider")+ first, err := signInWithTestingSSO(ctx, ts, idpName, "repeat-code")+ require.NoError(t, err)+ second, err := signInWithTestingSSO(ctx, ts, idpName, "repeat-code")+ require.NoError(t, err)+ require.Equal(t, first.User.Name, second.User.Name)+ require.Equal(t, first.User.Username, second.User.Username)++ users, err := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, err)+ require.Len(t, users, 1)+ assertSingleSSOLink(ctx, t, ts, "repeat-provider", test.identifier, first.User.Username)+ })+ }+}++func TestSSOSignInScopesSameIdentifierByProvider(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ firstMockIDP := newMockOAuthServer(t, "first-code", "first-token", map[string]any{"sub": "alice"})+ defer firstMockIDP.Close()+ secondMockIDP := newMockOAuthServer(t, "second-code", "second-token", map[string]any{"sub": "alice"})+ defer secondMockIDP.Close()++ firstIDPName := createTestingOAuthIdentityProvider(ctx, t, ts, firstMockIDP.URL, "provider-one")+ secondIDPName := createTestingOAuthIdentityProvider(ctx, t, ts, secondMockIDP.URL, "provider-two")++ first, err := signInWithTestingSSO(ctx, ts, firstIDPName, "first-code")+ require.NoError(t, err)+ second, err := signInWithTestingSSO(ctx, ts, secondIDPName, "second-code")+ require.NoError(t, err)+ require.Equal(t, "alice", first.User.Username)+ require.NotEqual(t, first.User.Name, second.User.Name)+ _, err = uuid.Parse(second.User.Username)+ require.NoError(t, err)++ users, err := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, err)+ require.Len(t, users, 2)+ identities, err := ts.Store.ListUserIdentities(ctx, &store.FindUserIdentity{ExternUID: ptr("alice")})+ require.NoError(t, err)+ require.Len(t, identities, 2)+}++func TestConcurrentSSOFirstSignInConvergesOnOneUser(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "concurrent-code", "concurrent-token", map[string]any{+ "sub": "alice",+ "name": "Alice Example",+ })+ defer mockIDP.Close()+ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "concurrent-provider")++ const signInCount = 8+ start := make(chan struct{})+ results := make(chan *v1pb.SignInResponse, signInCount)+ errs := make(chan error, signInCount)+ var waitGroup sync.WaitGroup+ for range signInCount {+ waitGroup.Add(1)+ go func() {+ defer waitGroup.Done()+ <-start+ response, err := signInWithTestingSSO(ctx, ts, idpName, "concurrent-code")+ results <- response+ errs <- err+ }()+ }++ close(start)+ waitGroup.Wait()+ close(results)+ close(errs)++ for err := range errs {+ require.NoError(t, err)+ }+ var userName string+ for response := range results {+ require.NotNil(t, response)+ if userName == "" {+ userName = response.User.Name+ } else {+ require.Equal(t, userName, response.User.Name)+ }+ }++ users, err := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, err)+ require.Len(t, users, 1)+ assertSingleSSOLink(ctx, t, ts, "concurrent-provider", "alice", "alice")+}++func TestSSOSignInRejectsEmptyIdentifierWithoutCreatingUser(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "empty-code", "empty-token", map[string]any{"sub": ""})+ defer mockIDP.Close()+ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "empty-identifier")++ // An empty subject must never provision an account. The OAuth2 layer rejects it+ // today, and resolveSSOUser guards it independently, so assert the invariant+ // that matters — no user or identity is created — rather than which layer's+ // error code surfaces.+ _, err := signInWithTestingSSO(ctx, ts, idpName, "empty-code")+ require.Error(t, err)+ require.NotEqual(t, codes.OK, status.Code(err))++ users, listErr := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, listErr)+ require.Empty(t, users)+ identities, listErr := ts.Store.ListUserIdentities(ctx, &store.FindUserIdentity{})+ require.NoError(t, listErr)+ require.Empty(t, identities)+}++func TestSSOSignInHonorsRegistrationGate(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ _, err := ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{+ Key: storepb.InstanceSettingKey_GENERAL,+ Value: &storepb.InstanceSetting_GeneralSetting{+ GeneralSetting: &storepb.InstanceGeneralSetting{DisallowUserRegistration: true},+ },+ })+ require.NoError(t, err)++ mockIDP := newMockOAuthServer(t, "blocked-code", "blocked-token", map[string]any{"sub": "alice"})+ defer mockIDP.Close()+ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "blocked-provider")++ _, err = signInWithTestingSSO(ctx, ts, idpName, "blocked-code")+ require.Error(t, err)+ require.Equal(t, codes.PermissionDenied, status.Code(err))++ users, listErr := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, listErr)+ require.Empty(t, users)+}++func TestSSOSignInAllowsLinkedUserWhenRegistrationDisabled(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()++ ctx := context.Background()+ mockIDP := newMockOAuthServer(t, "linked-code", "linked-token", map[string]any{"sub": "alice"})+ defer mockIDP.Close()+ idpName := createTestingOAuthIdentityProvider(ctx, t, ts, mockIDP.URL, "linked-provider")++ first, err := signInWithTestingSSO(ctx, ts, idpName, "linked-code")+ require.NoError(t, err)+ _, err = ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{+ Key: storepb.InstanceSettingKey_GENERAL,+ Value: &storepb.InstanceSetting_GeneralSetting{+ GeneralSetting: &storepb.InstanceGeneralSetting{DisallowUserRegistration: true},+ },+ })+ require.NoError(t, err)++ second, err := signInWithTestingSSO(ctx, ts, idpName, "linked-code")+ require.NoError(t, err)+ require.Equal(t, first.User.Name, second.User.Name)++ users, err := ts.Store.ListUsers(ctx, &store.FindUser{})+ require.NoError(t, err)+ require.Len(t, users, 1)+}++func signInWithTestingSSO(ctx context.Context, ts *TestService, idpName, code string) (*v1pb.SignInResponse, error) {+ return ts.Service.SignIn(apiv1.WithHeaderCarrier(ctx), &v1pb.SignInRequest{+ Credentials: &v1pb.SignInRequest_SsoCredentials{+ SsoCredentials: &v1pb.SignInRequest_SSOCredentials{+ IdpName: idpName,+ Code: code,+ RedirectUri: "http://localhost:8080/auth/callback",+ },+ },+ })+}++func assertSingleSSOLink(ctx context.Context, t *testing.T, ts *TestService, provider, externUID, username string) {+ t.Helper()++ identity, err := ts.Store.GetUserIdentity(ctx, &store.FindUserIdentity{+ Provider: &provider,+ ExternUID: &externUID,+ })+ require.NoError(t, err)+ require.NotNil(t, identity)++ user, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &identity.UserID})+ require.NoError(t, err)+ require.NotNil(t, user)+ require.Equal(t, username, user.Username)++ identities, err := ts.Store.ListUserIdentities(ctx, &store.FindUserIdentity{+ Provider: &provider,+ ExternUID: &externUID,+ })+ require.NoError(t, err)+ require.Len(t, identities, 1)+}++func ptr[T any](value T) *T {+ return &value+}diff --git a/store/db/mysql/user.go b/store/db/mysql/user.goindex f4b817257..128d1a6d6 100644--- a/store/db/mysql/user.go+++ b/store/db/mysql/user.go@@ -11,12 +11,7 @@ import ()func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, error) {- fields := []string{"`username`", "`role`", "`email`", "`nickname`", "`password_hash`", "`avatar_url`"}- placeholder := []string{"?", "?", "?", "?", "?", "?"}- args := []any{create.Username, create.Role, create.Email, create.Nickname, create.PasswordHash, create.AvatarURL}-- stmt := "INSERT INTO user (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ")"- result, err := d.db.ExecContext(ctx, stmt, args...)+ result, err := insertUser(ctx, d.db, create)if err != nil {return nil, err}diff --git a/store/db/mysql/user_identity.go b/store/db/mysql/user_identity.goindex de7da9e65..3140b0d56 100644--- a/store/db/mysql/user_identity.go+++ b/store/db/mysql/user_identity.go@@ -2,6 +2,7 @@ package mysqlimport ("context"+ "database/sql""strings""github.com/pkg/errors"@@ -9,11 +10,26 @@ import ("github.com/usememos/memos/store")-func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+// execer is satisfied by both *sql.DB and *sql.Tx so the INSERT statements can be+// shared between the standalone and transactional creation paths.+type execer interface {+ ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)+}++func insertUser(ctx context.Context, e execer, create *store.User) (sql.Result, error) {+ stmt := "INSERT INTO user (`username`, `role`, `email`, `nickname`, `password_hash`, `avatar_url`) VALUES (?, ?, ?, ?, ?, ?)"+ return e.ExecContext(ctx, stmt, create.Username, create.Role, create.Email, create.Nickname, create.PasswordHash, create.AvatarURL)+}++func insertUserIdentity(ctx context.Context, e execer, create *store.UserIdentity) (sql.Result, error) {stmt := "INSERT INTO `user_identity` (`user_id`, `provider`, `extern_uid`) VALUES (?, ?, ?)"- result, err := d.db.ExecContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID)+ return e.ExecContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID)+}++func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+ result, err := insertUserIdentity(ctx, d.db, create)if err != nil {- return nil, err+ return nil, errors.Wrap(err, "failed to create user identity")}rawID, err := result.LastInsertId()@@ -31,6 +47,57 @@ func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity)return list[0], nil}+func (d *DB) CreateUserWithIdentity(ctx context.Context, createUser *store.User, createIdentity *store.UserIdentity) (*store.User, error) {+ tx, err := d.db.BeginTx(ctx, nil)+ if err != nil {+ return nil, errors.Wrap(err, "failed to begin user identity transaction")+ }+ defer func() {+ _ = tx.Rollback()+ }()++ userResult, err := insertUser(ctx, tx, createUser)+ if err != nil {+ return nil, errors.Wrap(err, "failed to create user")+ }+ rawUserID, err := userResult.LastInsertId()+ if err != nil {+ return nil, errors.Wrap(err, "failed to read created user ID")+ }+ createUser.ID = int32(rawUserID)+ // RETURNING is unavailable on MySQL, so read back the complete stored row+ // within the same transaction before adding it to the user cache.+ if err := tx.QueryRowContext(+ ctx,+ "SELECT `id`, `username`, `role`, `email`, `nickname`, `password_hash`, `avatar_url`, `description`, UNIX_TIMESTAMP(`created_ts`), UNIX_TIMESTAMP(`updated_ts`), `row_status` FROM `user` WHERE `id` = ?",+ createUser.ID,+ ).Scan(+ &createUser.ID,+ &createUser.Username,+ &createUser.Role,+ &createUser.Email,+ &createUser.Nickname,+ &createUser.PasswordHash,+ &createUser.AvatarURL,+ &createUser.Description,+ &createUser.CreatedTs,+ &createUser.UpdatedTs,+ &createUser.RowStatus,+ ); err != nil {+ return nil, errors.Wrap(err, "failed to read created user")+ }++ createIdentity.UserID = createUser.ID+ if _, err := insertUserIdentity(ctx, tx, createIdentity); err != nil {+ return nil, errors.Wrap(err, "failed to create user identity")+ }++ if err := tx.Commit(); err != nil {+ return nil, errors.Wrap(err, "failed to commit user identity transaction")+ }+ return createUser, nil+}+func (d *DB) ListUserIdentities(ctx context.Context, find *store.FindUserIdentity) ([]*store.UserIdentity, error) {where, args := []string{"1 = 1"}, []any{}diff --git a/store/db/postgres/user.go b/store/db/postgres/user.goindex 8291a610d..eec831df9 100644--- a/store/db/postgres/user.go+++ b/store/db/postgres/user.go@@ -11,19 +11,9 @@ import ()func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, error) {- fields := []string{"username", "role", "email", "nickname", "password_hash", "avatar_url"}- args := []any{create.Username, create.Role, create.Email, create.Nickname, create.PasswordHash, create.AvatarURL}- stmt := "INSERT INTO \"user\" (" + strings.Join(fields, ", ") + ") VALUES (" + placeholders(len(args)) + ") RETURNING id, description, created_ts, updated_ts, row_status"- if err := d.db.QueryRowContext(ctx, stmt, args...).Scan(- &create.ID,- &create.Description,- &create.CreatedTs,- &create.UpdatedTs,- &create.RowStatus,- ); err != nil {+ if err := insertUser(ctx, d.db, create); err != nil {return nil, err}-return create, nil}diff --git a/store/db/postgres/user_identity.go b/store/db/postgres/user_identity.goindex 7a9ade6ee..51dc1c561 100644--- a/store/db/postgres/user_identity.go+++ b/store/db/postgres/user_identity.go@@ -2,23 +2,80 @@ package postgresimport ("context"+ "database/sql""strings"+ "github.com/pkg/errors"+"github.com/usememos/memos/store")-func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+// rowQuerier is satisfied by both *sql.DB and *sql.Tx so the insert statements+// can be shared between the standalone and transactional creation paths.+type rowQuerier interface {+ QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row+}++func insertUser(ctx context.Context, q rowQuerier, create *store.User) error {+ stmt := "INSERT INTO \"user\" (username, role, email, nickname, password_hash, avatar_url) VALUES (" + placeholders(6) + ") RETURNING id, description, created_ts, updated_ts, row_status"+ return q.QueryRowContext(+ ctx,+ stmt,+ create.Username,+ create.Role,+ create.Email,+ create.Nickname,+ create.PasswordHash,+ create.AvatarURL,+ ).Scan(+ &create.ID,+ &create.Description,+ &create.CreatedTs,+ &create.UpdatedTs,+ &create.RowStatus,+ )+}++func insertUserIdentity(ctx context.Context, q rowQuerier, create *store.UserIdentity) error {stmt := "INSERT INTO user_identity (user_id, provider, extern_uid) VALUES (" + placeholders(3) + ") RETURNING id, created_ts, updated_ts"- if err := d.db.QueryRowContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID).Scan(+ return q.QueryRowContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID).Scan(&create.ID,&create.CreatedTs,&create.UpdatedTs,- ); err != nil {- return nil, err+ )+}++func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+ if err := insertUserIdentity(ctx, d.db, create); err != nil {+ return nil, errors.Wrap(err, "failed to create user identity")}return create, nil}+func (d *DB) CreateUserWithIdentity(ctx context.Context, createUser *store.User, createIdentity *store.UserIdentity) (*store.User, error) {+ tx, err := d.db.BeginTx(ctx, nil)+ if err != nil {+ return nil, errors.Wrap(err, "failed to begin user identity transaction")+ }+ defer func() {+ _ = tx.Rollback()+ }()++ if err := insertUser(ctx, tx, createUser); err != nil {+ return nil, errors.Wrap(err, "failed to create user")+ }++ createIdentity.UserID = createUser.ID+ if err := insertUserIdentity(ctx, tx, createIdentity); err != nil {+ return nil, errors.Wrap(err, "failed to create user identity")+ }++ if err := tx.Commit(); err != nil {+ return nil, errors.Wrap(err, "failed to commit user identity transaction")+ }+ return createUser, nil+}+func (d *DB) ListUserIdentities(ctx context.Context, find *store.FindUserIdentity) ([]*store.UserIdentity, error) {where, args := []string{"1 = 1"}, []any{}diff --git a/store/db/sqlite/user.go b/store/db/sqlite/user.goindex cecbd46f2..e6b1d0948 100644--- a/store/db/sqlite/user.go+++ b/store/db/sqlite/user.go@@ -11,20 +11,9 @@ import ()func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, error) {- fields := []string{"`username`", "`role`", "`email`", "`nickname`", "`password_hash`, `avatar_url`"}- placeholder := []string{"?", "?", "?", "?", "?", "?"}- args := []any{create.Username, create.Role, create.Email, create.Nickname, create.PasswordHash, create.AvatarURL}- stmt := "INSERT INTO user (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ") RETURNING id, description, created_ts, updated_ts, row_status"- if err := d.db.QueryRowContext(ctx, stmt, args...).Scan(- &create.ID,- &create.Description,- &create.CreatedTs,- &create.UpdatedTs,- &create.RowStatus,- ); err != nil {+ if err := insertUser(ctx, d.db, create); err != nil {return nil, err}-return create, nil}diff --git a/store/db/sqlite/user_identity.go b/store/db/sqlite/user_identity.goindex e623ef630..9ad1a1a32 100644--- a/store/db/sqlite/user_identity.go+++ b/store/db/sqlite/user_identity.go@@ -2,23 +2,80 @@ package sqliteimport ("context"+ "database/sql""strings"+ "github.com/pkg/errors"+"github.com/usememos/memos/store")-func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+// rowQuerier is satisfied by both *sql.DB and *sql.Tx so the insert statements+// can be shared between the standalone and transactional creation paths.+type rowQuerier interface {+ QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row+}++func insertUser(ctx context.Context, q rowQuerier, create *store.User) error {+ stmt := "INSERT INTO user (`username`, `role`, `email`, `nickname`, `password_hash`, `avatar_url`) VALUES (?, ?, ?, ?, ?, ?) RETURNING id, description, created_ts, updated_ts, row_status"+ return q.QueryRowContext(+ ctx,+ stmt,+ create.Username,+ create.Role,+ create.Email,+ create.Nickname,+ create.PasswordHash,+ create.AvatarURL,+ ).Scan(+ &create.ID,+ &create.Description,+ &create.CreatedTs,+ &create.UpdatedTs,+ &create.RowStatus,+ )+}++func insertUserIdentity(ctx context.Context, q rowQuerier, create *store.UserIdentity) error {stmt := "INSERT INTO `user_identity` (`user_id`, `provider`, `extern_uid`) VALUES (?, ?, ?) RETURNING `id`, `created_ts`, `updated_ts`"- if err := d.db.QueryRowContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID).Scan(+ return q.QueryRowContext(ctx, stmt, create.UserID, create.Provider, create.ExternUID).Scan(&create.ID,&create.CreatedTs,&create.UpdatedTs,- ); err != nil {- return nil, err+ )+}++func (d *DB) CreateUserIdentity(ctx context.Context, create *store.UserIdentity) (*store.UserIdentity, error) {+ if err := insertUserIdentity(ctx, d.db, create); err != nil {+ return nil, errors.Wrap(err, "failed to create user identity")}return create, nil}+func (d *DB) CreateUserWithIdentity(ctx context.Context, createUser *store.User, createIdentity *store.UserIdentity) (*store.User, error) {+ tx, err := d.db.BeginTx(ctx, nil)+ if err != nil {+ return nil, errors.Wrap(err, "failed to begin user identity transaction")+ }+ defer func() {+ _ = tx.Rollback()+ }()++ if err := insertUser(ctx, tx, createUser); err != nil {+ return nil, errors.Wrap(err, "failed to create user")+ }++ createIdentity.UserID = createUser.ID+ if err := insertUserIdentity(ctx, tx, createIdentity); err != nil {+ return nil, errors.Wrap(err, "failed to create user identity")+ }++ if err := tx.Commit(); err != nil {+ return nil, errors.Wrap(err, "failed to commit user identity transaction")+ }+ return createUser, nil+}+func (d *DB) ListUserIdentities(ctx context.Context, find *store.FindUserIdentity) ([]*store.UserIdentity, error) {where, args := []string{"1 = 1"}, []any{}diff --git a/store/driver.go b/store/driver.goindex 45f19bb07..5a265bddf 100644--- a/store/driver.go+++ b/store/driver.go@@ -81,6 +81,7 @@ type Driver interface {// UserIdentity model related methods.CreateUserIdentity(ctx context.Context, create *UserIdentity) (*UserIdentity, error)+ CreateUserWithIdentity(ctx context.Context, createUser *User, createIdentity *UserIdentity) (*User, error)ListUserIdentities(ctx context.Context, find *FindUserIdentity) ([]*UserIdentity, error)DeleteUserIdentities(ctx context.Context, delete *DeleteUserIdentity) error}diff --git a/store/test/user_identity_test.go b/store/test/user_identity_test.goindex 7cf62a978..04a345c44 100644--- a/store/test/user_identity_test.go+++ b/store/test/user_identity_test.go@@ -161,6 +161,80 @@ func TestUserIdentitySameUserSameProviderConflicts(t *testing.T) {require.Error(t, err)}+func TestCreateUserWithIdentityIsAtomic(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ defer ts.Close()++ t.Run("creates both records", func(t *testing.T) {+ provider := "atomic-provider"+ externUID := "atomic-subject"+ user, err := ts.CreateUserWithIdentity(ctx, &store.User{+ Username: "atomic-user",+ Role: store.RoleUser,+ }, &store.UserIdentity{+ Provider: provider,+ ExternUID: externUID,+ })+ require.NoError(t, err)+ require.NotZero(t, user.ID)++ storedIdentity, err := ts.GetUserIdentity(ctx, &store.FindUserIdentity{Provider: &provider, ExternUID: &externUID})+ require.NoError(t, err)+ require.NotNil(t, storedIdentity)+ require.Equal(t, user.ID, storedIdentity.UserID)+ })++ t.Run("rolls back user when identity conflicts", func(t *testing.T) {+ owner, err := createTestingUserWithRole(ctx, ts, "identity-owner", store.RoleUser)+ require.NoError(t, err)+ _, err = ts.CreateUserIdentity(ctx, &store.UserIdentity{+ UserID: owner.ID,+ Provider: "conflict-provider",+ ExternUID: "conflict-subject",+ })+ require.NoError(t, err)++ _, err = ts.CreateUserWithIdentity(ctx, &store.User{+ Username: "rolled-back-user",+ Role: store.RoleUser,+ }, &store.UserIdentity{+ Provider: "conflict-provider",+ ExternUID: "conflict-subject",+ })+ require.Error(t, err)++ username := "rolled-back-user"+ user, err := ts.GetUser(ctx, &store.FindUser{Username: &username})+ require.NoError(t, err)+ require.Nil(t, user)+ })++ t.Run("rolls back identity when username conflicts", func(t *testing.T) {+ _, err := createTestingUserWithRole(ctx, ts, "taken-username", store.RoleUser)+ require.NoError(t, err)++ _, err = ts.CreateUserWithIdentity(ctx, &store.User{+ Username: "taken-username",+ Role: store.RoleUser,+ }, &store.UserIdentity{+ Provider: "unused-provider",+ ExternUID: "unused-subject",+ })+ require.Error(t, err)++ provider := "unused-provider"+ externUID := "unused-subject"+ identity, err := ts.GetUserIdentity(ctx, &store.FindUserIdentity{+ Provider: &provider,+ ExternUID: &externUID,+ })+ require.NoError(t, err)+ require.Nil(t, identity)+ })+}+func TestUserIdentityDeleteByUserAndProvider(t *testing.T) {t.Parallel()ctx := context.Background()diff --git a/store/user_identity.go b/store/user_identity.goindex 4992ec3c7..88d90706e 100644--- a/store/user_identity.go+++ b/store/user_identity.go@@ -36,6 +36,17 @@ func (s *Store) CreateUserIdentity(ctx context.Context, create *UserIdentity) (*return s.driver.CreateUserIdentity(ctx, create)}+// CreateUserWithIdentity atomically creates a local user and its external identity+// linkage, returning the created user.+func (s *Store) CreateUserWithIdentity(ctx context.Context, createUser *User, createIdentity *UserIdentity) (*User, error) {+ user, err := s.driver.CreateUserWithIdentity(ctx, createUser, createIdentity)+ if err != nil {+ return nil, err+ }+ s.userCache.Set(ctx, userCacheKey(user.ID), user)+ return user, nil+}+// ListUserIdentities returns all linkage records matching the filter.func (s *Store) ListUserIdentities(ctx context.Context, find *FindUserIdentity) ([]*UserIdentity, error) {return s.driver.ListUserIdentities(ctx, find)