Migrate User.GetAllAfter to Sync by default (#11446)

app/export.go

@@ -177,14 +177,12 @@ func (a *App) ExportAllChannels(writer io.Writer) *model.AppError {
 func (a *App) ExportAllUsers(writer io.Writer) *model.AppError {
 	afterId := strings.Repeat("0", 26)
 	for {
-		result := <-a.Srv.Store.User().GetAllAfter(1000, afterId)
+		users, err := a.Srv.Store.User().GetAllAfter(1000, afterId)
 
-		if result.Err != nil {
+		if err != nil {
-			return result.Err
+			return err
 		}
 
-		users := result.Data.([]*model.User)
-
 		if len(users) == 0 {
 			break
 		}

store/sqlstore/user_store.go

@@ -366,26 +366,23 @@ func (us SqlUserStore) GetAll() store.StoreChannel {
 	})
 }
 
-func (us SqlUserStore) GetAllAfter(limit int, afterId string) store.StoreChannel {
+func (us SqlUserStore) GetAllAfter(limit int, afterId string) ([]*model.User, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	query := us.usersQuery.
-		query := us.usersQuery.
+		Where("Id > ?", afterId).
-			Where("Id > ?", afterId).
+		OrderBy("Id ASC").
-			OrderBy("Id ASC").
+		Limit(uint64(limit))
-			Limit(uint64(limit))
 
-		queryString, args, err := query.ToSql()
+	queryString, args, err := query.ToSql()
-		if err != nil {
+	if err != nil {
-			result.Err = model.NewAppError("SqlUserStore.GetAllAfter", "store.sql_user.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlUserStore.GetAllAfter", "store.sql_user.app_error", nil, err.Error(), http.StatusInternalServerError)
-			return
+	}
-		}
 
-		var data []*model.User
+	var users []*model.User
-		if _, err := us.GetReplica().Select(&data, queryString, args...); err != nil {
+	if _, err := us.GetReplica().Select(&users, queryString, args...); err != nil {
-			result.Err = model.NewAppError("SqlUserStore.GetAllAfter", "store.sql_user.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlUserStore.GetAllAfter", "store.sql_user.get.app_error", nil, err.Error(), http.StatusInternalServerError)
-		}
+	}
 
-		result.Data = data
+	return users, nil
-	})
 }
 
 func (s SqlUserStore) GetEtagForAllProfiles() store.StoreChannel {

store/store.go

@@ -299,7 +299,7 @@ type UserStore interface {
 	GetEtagForProfilesNotInTeam(teamId string) StoreChannel
 	ClearAllCustomRoleAssignments() StoreChannel
 	InferSystemInstallDate() StoreChannel
-	GetAllAfter(limit int, afterId string) StoreChannel
+	GetAllAfter(limit int, afterId string) ([]*model.User, *model.AppError)
 	GetUsersBatchForIndexing(startTime, endTime int64, limit int) ([]*model.UserForIndexing, *model.AppError)
 	Count(options model.UserCountOptions) (int64, *model.AppError)
 	GetTeamGroupUsers(teamID string) ([]*model.User, *model.AppError)

store/storetest/mocks/UserStore.go

@@ -147,19 +147,28 @@ func (_m *UserStore) GetAll() store.StoreChannel {
 }
 
 // GetAllAfter provides a mock function with given fields: limit, afterId
-func (_m *UserStore) GetAllAfter(limit int, afterId string) store.StoreChannel {
+func (_m *UserStore) GetAllAfter(limit int, afterId string) ([]*model.User, *model.AppError) {
 	ret := _m.Called(limit, afterId)
 
-	var r0 store.StoreChannel
+	var r0 []*model.User
-	if rf, ok := ret.Get(0).(func(int, string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(int, string) []*model.User); ok {
 		r0 = rf(limit, afterId)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.User)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(int, string) *model.AppError); ok {
+		r1 = rf(limit, afterId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetAllProfiles provides a mock function with given fields: options

store/storetest/user_store.go

@@ -3567,26 +3567,23 @@ func testUserStoreGetAllAfter(t *testing.T, ss store.Store) {
 	}
 
 	t.Run("get after lowest possible id", func(t *testing.T) {
-		result := <-ss.User().GetAllAfter(10000, strings.Repeat("0", 26))
+		actual, err := ss.User().GetAllAfter(10000, strings.Repeat("0", 26))
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
 
-		actual := result.Data.([]*model.User)
 		assert.Equal(t, expected, actual)
 	})
 
 	t.Run("get after first user", func(t *testing.T) {
-		result := <-ss.User().GetAllAfter(10000, expected[0].Id)
+		actual, err := ss.User().GetAllAfter(10000, expected[0].Id)
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
 
-		actual := result.Data.([]*model.User)
 		assert.Equal(t, []*model.User{expected[1]}, actual)
 	})
 
 	t.Run("get after second user", func(t *testing.T) {
-		result := <-ss.User().GetAllAfter(10000, expected[1].Id)
+		actual, err := ss.User().GetAllAfter(10000, expected[1].Id)
-		require.Nil(t, result.Err)
+		require.Nil(t, err)
 
-		actual := result.Data.([]*model.User)
 		assert.Equal(t, []*model.User{}, actual)
 	})
 }