refactor: 3.7.0 code conventions. (#2148)

* Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * feat: add code lint * feat: add code lint * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * Script Refactoring * feat: code format * Script Refactoring * Script Refactoring * Script Refactoring * Adjust MinIO configuration settings * Adjust configuration settings * Adjust configuration settings * refactor: config change. * refactor: webhooks update. * Adjust configuration settings * refactor: webhooks update. * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * feat: s3 api addr * refactor: webhooks update. * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * Adjust configuration settings * refactor: webhooks update. * refactor: kafka update. * Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service. * refactor: kafka update. * refactor: kafka update. * Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service. * Simplify the Docker Compose configuration, remove unnecessary environment variables, and eliminate the gateway service. * Windows can compile and run. * Windows can compile and run. * refactor: kafka update. * feat: msg cache split * refactor: webhooks update * refactor: webhooks update * refactor: friends update * refactor: group update * refactor: third update * refactor: api update * refactor: crontab update * refactor: msggateway update * mage * mage * refactor: all module update. * check * refactor: all module update. * load config * load config * load config * load config * refactor: all module update. * refactor: all module update. * refactor: all module update. * refactor: all module update. * refactor: all module update. * Optimize Docker configuration and script. * refactor: all module update. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * refactor: all module update. * Optimize Docker configuration and script. * refactor: all module update. * refactor: all module update. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * update tools * update tools * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * update protocol * Optimize Docker configuration and script. * Optimize Docker configuration and script. * refactor: all module update. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * Optimize Docker configuration and script. * refactor: api remove token auth by redis directly. * Code Refactoring * refactor: websocket auth change to call rpc of auth. * refactor: kick online user and remove token change to call auth rpc. * refactor: kick online user and remove token change to call auth rpc. * refactor: remove msggateway redis. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor webhook * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor webhook * refactor: cmd update. * refactor: cmd update. * fix: runtime: goroutine stack exceeds * refactor: cmd update. * refactor notification * refactor notification * refactor * refactor: cmd update. * refactor: cmd update. * refactor * refactor * refactor * protojson * protojson * protojson * go mod * wrapperspb * refactor: cmd update. * refactor: cmd update. * refactor: cmd update. * refactor: context update. * refactor: websocket update info. * refactor: websocket update info. * refactor: websocket update info. * refactor: websocket update info. * refactor: api name change. * refactor: debug info. * refactor: debug info. * refactor: debug info. * fix: update file * refactor * refactor * refactor: debug info. * refactor: debug info. * refactor: debug info. * refactor: debug info. * refactor: debug info. * refactor: debug info. * fix: callback update. * fix: callback update. * refactor * fix: update message. * fix: msg cache timeout. * refactor * refactor * fix: push update. * fix: push update. * fix: push update. * fix: push update. * fix: push update. * fix: push update. * fix: push update. * fix: websocket handle error remove when upgrade error. --------- Co-authored-by: skiffer-git <44203734@qq.com> Co-authored-by: Xinwei Xiong (cubxxw) <3293172751nss@gmail.com> Co-authored-by: withchao <993506633@qq.com>
2024-04-19 22:23:08 +08:00
parent cca5336a8a
commit b76816bc14
438 changed files with 11525 additions and 15033 deletions
@@ -17,9 +17,9 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -63,42 +63,42 @@ func (b *BlackMgo) blacksFilter(blacks []*relation.BlackModel) bson.M {
 }

 func (b *BlackMgo) Create(ctx context.Context, blacks []*relation.BlackModel) (err error) {
-	return mgoutil.InsertMany(ctx, b.coll, blacks)
+	return mongoutil.InsertMany(ctx, b.coll, blacks)
 }

 func (b *BlackMgo) Delete(ctx context.Context, blacks []*relation.BlackModel) (err error) {
 	if len(blacks) == 0 {
 		return nil
 	}
-	return mgoutil.DeleteMany(ctx, b.coll, b.blacksFilter(blacks))
+	return mongoutil.DeleteMany(ctx, b.coll, b.blacksFilter(blacks))
 }

 func (b *BlackMgo) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, b.coll, b.blackFilter(ownerUserID, blockUserID), bson.M{"$set": args}, false)
+	return mongoutil.UpdateOne(ctx, b.coll, b.blackFilter(ownerUserID, blockUserID), bson.M{"$set": args}, false)
 }

 func (b *BlackMgo) Find(ctx context.Context, blacks []*relation.BlackModel) (blackList []*relation.BlackModel, err error) {
-	return mgoutil.Find[*relation.BlackModel](ctx, b.coll, b.blacksFilter(blacks))
+	return mongoutil.Find[*relation.BlackModel](ctx, b.coll, b.blacksFilter(blacks))
 }

 func (b *BlackMgo) Take(ctx context.Context, ownerUserID, blockUserID string) (black *relation.BlackModel, err error) {
-	return mgoutil.FindOne[*relation.BlackModel](ctx, b.coll, b.blackFilter(ownerUserID, blockUserID))
+	return mongoutil.FindOne[*relation.BlackModel](ctx, b.coll, b.blackFilter(ownerUserID, blockUserID))
 }

 func (b *BlackMgo) FindOwnerBlacks(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (total int64, blacks []*relation.BlackModel, err error) {
-	return mgoutil.FindPage[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, pagination)
+	return mongoutil.FindPage[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, pagination)
 }

 func (b *BlackMgo) FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*relation.BlackModel, err error) {
 	if len(userIDs) == 0 {
-		return mgoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID})
+		return mongoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID})
 	}
-	return mgoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID, "block_user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID, "block_user_id": bson.M{"$in": userIDs}})
 }

 func (b *BlackMgo) FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) {
-	return mgoutil.Find[string](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, options.Find().SetProjection(bson.M{"_id": 0, "block_user_id": 1}))
+	return mongoutil.Find[string](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, options.Find().SetProjection(bson.M{"_id": 0, "block_user_id": 1}))
 }
@@ -18,11 +18,11 @@ import (
 	"context"
 	"time"

-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -48,15 +48,15 @@ type ConversationMgo struct {
 }

 func (c *ConversationMgo) Create(ctx context.Context, conversations []*relation.ConversationModel) (err error) {
-	return mgoutil.InsertMany(ctx, c.coll, conversations)
+	return mongoutil.InsertMany(ctx, c.coll, conversations)
 }

 func (c *ConversationMgo) Delete(ctx context.Context, groupIDs []string) (err error) {
-	return mgoutil.DeleteMany(ctx, c.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
+	return mongoutil.DeleteMany(ctx, c.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
 }

 func (c *ConversationMgo) UpdateByMap(ctx context.Context, userIDs []string, conversationID string, args map[string]any) (rows int64, err error) {
-	res, err := mgoutil.UpdateMany(ctx, c.coll, bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": conversationID}, bson.M{"$set": args})
+	res, err := mongoutil.UpdateMany(ctx, c.coll, bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": conversationID}, bson.M{"$set": args})
 	if err != nil {
 		return 0, err
 	}
@@ -64,36 +64,35 @@ func (c *ConversationMgo) UpdateByMap(ctx context.Context, userIDs []string, con
 }

 func (c *ConversationMgo) Update(ctx context.Context, conversation *relation.ConversationModel) (err error) {
-	return mgoutil.UpdateOne(ctx, c.coll, bson.M{"owner_user_id": conversation.OwnerUserID, "conversation_id": conversation.ConversationID}, bson.M{"$set": conversation}, true)
+	return mongoutil.UpdateOne(ctx, c.coll, bson.M{"owner_user_id": conversation.OwnerUserID, "conversation_id": conversation.ConversationID}, bson.M{"$set": conversation}, true)
 }

 func (c *ConversationMgo) Find(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []*relation.ConversationModel, err error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": bson.M{"$in": conversationIDs}})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": bson.M{"$in": conversationIDs}})
 }

 func (c *ConversationMgo) FindUserID(ctx context.Context, userIDs []string, conversationIDs []string) ([]string, error) {
-	return mgoutil.Find[string](
+	return mongoutil.Find[string](
 		ctx,
 		c.coll,
 		bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": bson.M{"$in": conversationIDs}},
 		options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}),
 	)
 }
-
 func (c *ConversationMgo) FindUserIDAllConversationID(ctx context.Context, userID string) ([]string, error) {
-	return mgoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
 }

 func (c *ConversationMgo) Take(ctx context.Context, userID, conversationID string) (conversation *relation.ConversationModel, err error) {
-	return mgoutil.FindOne[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": conversationID})
+	return mongoutil.FindOne[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": conversationID})
 }

 func (c *ConversationMgo) FindConversationID(ctx context.Context, userID string, conversationIDs []string) (existConversationID []string, err error) {
-	return mgoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": bson.M{"$in": conversationIDs}}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": bson.M{"$in": conversationIDs}}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
 }

 func (c *ConversationMgo) FindUserIDAllConversations(ctx context.Context, userID string) (conversations []*relation.ConversationModel, err error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID})
 }

 func (c *ConversationMgo) FindRecvMsgUserIDs(ctx context.Context, conversationID string, recvOpts []int) ([]string, error) {
@@ -103,22 +102,22 @@ func (c *ConversationMgo) FindRecvMsgUserIDs(ctx context.Context, conversationID
 	} else {
 		filter = bson.M{"conversation_id": conversationID, "recv_msg_opt": bson.M{"$in": recvOpts}}
 	}
-	return mgoutil.Find[string](ctx, c.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}))
 }

 func (c *ConversationMgo) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) {
-	return mgoutil.FindOne[int](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": conversationID}, options.FindOne().SetProjection(bson.M{"recv_msg_opt": 1}))
+	return mongoutil.FindOne[int](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": conversationID}, options.FindOne().SetProjection(bson.M{"recv_msg_opt": 1}))
 }

 func (c *ConversationMgo) GetAllConversationIDs(ctx context.Context) ([]string, error) {
-	return mgoutil.Aggregate[string](ctx, c.coll, []bson.M{
+	return mongoutil.Aggregate[string](ctx, c.coll, []bson.M{
 		{"$group": bson.M{"_id": "$conversation_id"}},
 		{"$project": bson.M{"_id": 0, "conversation_id": "$_id"}},
 	})
 }

 func (c *ConversationMgo) GetAllConversationIDsNumber(ctx context.Context) (int64, error) {
-	counts, err := mgoutil.Aggregate[int64](ctx, c.coll, []bson.M{
+	counts, err := mongoutil.Aggregate[int64](ctx, c.coll, []bson.M{
 		{"$group": bson.M{"_id": "$conversation_id"}},
 		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": 1}}},
 		{"$project": bson.M{"_id": 0}},
@@ -133,16 +132,16 @@ func (c *ConversationMgo) GetAllConversationIDsNumber(ctx context.Context) (int6
 }

 func (c *ConversationMgo) PageConversationIDs(ctx context.Context, pagination pagination.Pagination) (conversationIDs []string, err error) {
-	return mgoutil.FindPageOnly[string](ctx, c.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"conversation_id": 1}))
+	return mongoutil.FindPageOnly[string](ctx, c.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"conversation_id": 1}))
 }

 func (c *ConversationMgo) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*relation.ConversationModel, error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"conversation_id": bson.M{"$in": conversationIDs}})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"conversation_id": bson.M{"$in": conversationIDs}})
 }

 func (c *ConversationMgo) GetConversationIDsNeedDestruct(ctx context.Context) ([]*relation.ConversationModel, error) {
-	//"is_msg_destruct = 1 && msg_destruct_time != 0 && (UNIX_TIMESTAMP(NOW()) > (msg_destruct_time + UNIX_TIMESTAMP(latest_msg_destruct_time)) || latest_msg_destruct_time is NULL)"
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{
+	// "is_msg_destruct = 1 && msg_destruct_time != 0 && (UNIX_TIMESTAMP(NOW()) > (msg_destruct_time + UNIX_TIMESTAMP(latest_msg_destruct_time)) || latest_msg_destruct_time is NULL)"
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{
 		"is_msg_destruct":   1,
 		"msg_destruct_time": bson.M{"$ne": 0},
 		"$or": []bson.M{
@@ -162,7 +161,7 @@ func (c *ConversationMgo) GetConversationIDsNeedDestruct(ctx context.Context) ([
 }

 func (c *ConversationMgo) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) {
-	return mgoutil.Find[string](
+	return mongoutil.Find[string](
 		ctx,
 		c.coll,
 		bson.M{"conversation_id": conversationID, "recv_msg_opt": bson.M{"$ne": constant.ReceiveMessage}},
@@ -0,0 +1,15 @@
+// Copyright © 2024 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mgo // import "github.com/openimsdk/open-im-server/v3/pkg/common/db/mgo"
@@ -17,9 +17,9 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -48,7 +48,7 @@ func NewFriendMongo(db *mongo.Database) (relation.FriendModelInterface, error) {

 // Create inserts multiple friend records.
 func (f *FriendMgo) Create(ctx context.Context, friends []*relation.FriendModel) error {
-	return mgoutil.InsertMany(ctx, f.coll, friends)
+	return mongoutil.InsertMany(ctx, f.coll, friends)
 }

 // Delete removes specified friends of the owner user.
@@ -57,7 +57,7 @@ func (f *FriendMgo) Delete(ctx context.Context, ownerUserID string, friendUserID
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": bson.M{"$in": friendUserIDs},
 	}
-	return mgoutil.DeleteOne(ctx, f.coll, filter)
+	return mongoutil.DeleteOne(ctx, f.coll, filter)
 }

 // UpdateByMap updates specific fields of a friend document using a map.
@@ -69,7 +69,7 @@ func (f *FriendMgo) UpdateByMap(ctx context.Context, ownerUserID string, friendU
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": args}, true)
 }

 // Update modifies multiple friend documents.
@@ -92,7 +92,7 @@ func (f *FriendMgo) Take(ctx context.Context, ownerUserID, friendUserID string)
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.FindOne[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.FindOne[*relation.FriendModel](ctx, f.coll, filter)
 }

 // FindUserState finds the friendship status between two users.
@@ -103,7 +103,7 @@ func (f *FriendMgo) FindUserState(ctx context.Context, userID1, userID2 string)
 			{"owner_user_id": userID2, "friend_user_id": userID1},
 		},
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }

 // FindFriends retrieves a list of friends for a given owner. Missing friends do not cause an error.
@@ -112,7 +112,7 @@ func (f *FriendMgo) FindFriends(ctx context.Context, ownerUserID string, friendU
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": bson.M{"$in": friendUserIDs},
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }

 // FindReversalFriends finds users who have added the specified user as a friend.
@@ -121,25 +121,25 @@ func (f *FriendMgo) FindReversalFriends(ctx context.Context, friendUserID string
 		"owner_user_id":  bson.M{"$in": ownerUserIDs},
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }

 // FindOwnerFriends retrieves a paginated list of friends for a given owner.
 func (f *FriendMgo) FindOwnerFriends(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (int64, []*relation.FriendModel, error) {
 	filter := bson.M{"owner_user_id": ownerUserID}
-	return mgoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
 }

 // FindInWhoseFriends finds users who have added the specified user as a friend, with pagination.
 func (f *FriendMgo) FindInWhoseFriends(ctx context.Context, friendUserID string, pagination pagination.Pagination) (int64, []*relation.FriendModel, error) {
 	filter := bson.M{"friend_user_id": friendUserID}
-	return mgoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
 }

 // FindFriendUserIDs retrieves a list of friend user IDs for a given owner.
 func (f *FriendMgo) FindFriendUserIDs(ctx context.Context, ownerUserID string) ([]string, error) {
 	filter := bson.M{"owner_user_id": ownerUserID}
-	return mgoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}))
+	return mongoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}))
 }

 func (f *FriendMgo) UpdateFriends(ctx context.Context, ownerUserID string, friendUserIDs []string, val map[string]any) error {
@@ -158,6 +158,6 @@ func (f *FriendMgo) UpdateFriends(ctx context.Context, ownerUserID string, frien
 	update := bson.M{"$set": val}

 	// Perform the update operation for all matching documents
-	_, err := mgoutil.UpdateMany(ctx, f.coll, filter, update)
+	_, err := mongoutil.UpdateMany(ctx, f.coll, filter, update)
 	return err
 }
@@ -17,9 +17,9 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -45,11 +45,11 @@ type FriendRequestMgo struct {
 }

 func (f *FriendRequestMgo) FindToUserID(ctx context.Context, toUserID string, pagination pagination.Pagination) (total int64, friendRequests []*relation.FriendRequestModel, err error) {
-	return mgoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"to_user_id": toUserID}, pagination)
+	return mongoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"to_user_id": toUserID}, pagination)
 }

 func (f *FriendRequestMgo) FindFromUserID(ctx context.Context, fromUserID string, pagination pagination.Pagination) (total int64, friendRequests []*relation.FriendRequestModel, err error) {
-	return mgoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID}, pagination)
+	return mongoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID}, pagination)
 }

 func (f *FriendRequestMgo) FindBothFriendRequests(ctx context.Context, fromUserID, toUserID string) (friends []*relation.FriendRequestModel, err error) {
@@ -57,22 +57,22 @@ func (f *FriendRequestMgo) FindBothFriendRequests(ctx context.Context, fromUserI
 		{"from_user_id": fromUserID, "to_user_id": toUserID},
 		{"from_user_id": toUserID, "to_user_id": fromUserID},
 	}}
-	return mgoutil.Find[*relation.FriendRequestModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendRequestModel](ctx, f.coll, filter)
 }

 func (f *FriendRequestMgo) Create(ctx context.Context, friendRequests []*relation.FriendRequestModel) error {
-	return mgoutil.InsertMany(ctx, f.coll, friendRequests)
+	return mongoutil.InsertMany(ctx, f.coll, friendRequests)
 }

 func (f *FriendRequestMgo) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
-	return mgoutil.DeleteOne(ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
+	return mongoutil.DeleteOne(ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
 }

 func (f *FriendRequestMgo) UpdateByMap(ctx context.Context, formUserID, toUserID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, f.coll, bson.M{"from_user_id": formUserID, "to_user_id": toUserID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, bson.M{"from_user_id": formUserID, "to_user_id": toUserID}, bson.M{"$set": args}, true)
 }

 func (f *FriendRequestMgo) Update(ctx context.Context, friendRequest *relation.FriendRequestModel) (err error) {
@@ -99,11 +99,11 @@ func (f *FriendRequestMgo) Update(ctx context.Context, friendRequest *relation.F
 		return nil
 	}
 	filter := bson.M{"from_user_id": friendRequest.FromUserID, "to_user_id": friendRequest.ToUserID}
-	return mgoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": updater}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": updater}, true)
 }

 func (f *FriendRequestMgo) Find(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
-	return mgoutil.FindOne[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
+	return mongoutil.FindOne[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
 }

 func (f *FriendRequestMgo) Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
@@ -18,11 +18,11 @@ import (
 	"context"
 	"time"

-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -47,7 +47,7 @@ type GroupMgo struct {
 }

 func (g *GroupMgo) Create(ctx context.Context, groups []*relation.GroupModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groups)
+	return mongoutil.InsertMany(ctx, g.coll, groups)
 }

 func (g *GroupMgo) UpdateStatus(ctx context.Context, groupID string, status int32) (err error) {
@@ -58,21 +58,23 @@ func (g *GroupMgo) UpdateMap(ctx context.Context, groupID string, args map[strin
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID}, bson.M{"$set": args}, true)
 }

 func (g *GroupMgo) Find(ctx context.Context, groupIDs []string) (groups []*relation.GroupModel, err error) {
-	return mgoutil.Find[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
+	return mongoutil.Find[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
 }

 func (g *GroupMgo) Take(ctx context.Context, groupID string) (group *relation.GroupModel, err error) {
-	return mgoutil.FindOne[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": groupID})
+	return mongoutil.FindOne[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": groupID})
 }

 func (g *GroupMgo) Search(ctx context.Context, keyword string, pagination pagination.Pagination) (total int64, groups []*relation.GroupModel, err error) {
+	// Define the sorting options
 	opts := options.Find().SetSort(bson.D{{Key: "created_at", Value: -1}})

-	return mgoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{
+	// Perform the search with pagination and sorting
+	return mongoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{
 		"group_name": bson.M{"$regex": keyword},
 		"status":     bson.M{"$ne": constant.GroupStatusDismissed},
 	}, pagination, opts)
@@ -80,9 +82,9 @@ func (g *GroupMgo) Search(ctx context.Context, keyword string, pagination pagina

 func (g *GroupMgo) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) {
 	if before == nil {
-		return mgoutil.Count(ctx, g.coll, bson.M{})
+		return mongoutil.Count(ctx, g.coll, bson.M{})
 	}
-	return mgoutil.Count(ctx, g.coll, bson.M{"create_time": bson.M{"$lt": before}})
+	return mongoutil.Count(ctx, g.coll, bson.M{"create_time": bson.M{"$lt": before}})
 }

 func (g *GroupMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error) {
@@ -113,7 +115,7 @@ func (g *GroupMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time,
 		Date  string `bson:"_id"`
 		Count int64  `bson:"count"`
 	}
-	items, err := mgoutil.Aggregate[Item](ctx, g.coll, pipeline)
+	items, err := mongoutil.Aggregate[Item](ctx, g.coll, pipeline)
 	if err != nil {
 		return nil, err
 	}
@@ -17,11 +17,11 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/protocol/constant"
-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -47,7 +47,7 @@ type GroupMemberMgo struct {
 }

 func (g *GroupMemberMgo) Create(ctx context.Context, groupMembers []*relation.GroupMemberModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groupMembers)
+	return mongoutil.InsertMany(ctx, g.coll, groupMembers)
 }

 func (g *GroupMemberMgo) Delete(ctx context.Context, groupID string, userIDs []string) (err error) {
@@ -55,7 +55,7 @@ func (g *GroupMemberMgo) Delete(ctx context.Context, groupID string, userIDs []s
 	if len(userIDs) > 0 {
 		filter["user_id"] = bson.M{"$in": userIDs}
 	}
-	return mgoutil.DeleteMany(ctx, g.coll, filter)
+	return mongoutil.DeleteMany(ctx, g.coll, filter)
 }

 func (g *GroupMemberMgo) UpdateRoleLevel(ctx context.Context, groupID string, userID string, roleLevel int32) error {
@@ -63,41 +63,41 @@ func (g *GroupMemberMgo) UpdateRoleLevel(ctx context.Context, groupID string, us
 }

 func (g *GroupMemberMgo) Update(ctx context.Context, groupID string, userID string, data map[string]any) (err error) {
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": data}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": data}, true)
 }

 func (g *GroupMemberMgo) Find(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) (groupMembers []*relation.GroupMemberModel, err error) {
-	//TODO implement me
+	// TODO implement me
 	panic("implement me")
 }

 func (g *GroupMemberMgo) FindMemberUserID(ctx context.Context, groupID string) (userIDs []string, err error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }

 func (g *GroupMemberMgo) Take(ctx context.Context, groupID string, userID string) (groupMember *relation.GroupMemberModel, err error) {
-	return mgoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }

 func (g *GroupMemberMgo) TakeOwner(ctx context.Context, groupID string) (groupMember *relation.GroupMemberModel, err error) {
-	return mgoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "role_level": constant.GroupOwner})
+	return mongoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "role_level": constant.GroupOwner})
 }

 func (g *GroupMemberMgo) FindRoleLevelUserIDs(ctx context.Context, groupID string, roleLevel int32) ([]string, error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID, "role_level": roleLevel}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID, "role_level": roleLevel}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }

 func (g *GroupMemberMgo) SearchMember(ctx context.Context, keyword string, groupID string, pagination pagination.Pagination) (total int64, groupList []*relation.GroupMemberModel, err error) {
 	filter := bson.M{"group_id": groupID, "nickname": bson.M{"$regex": keyword}}
-	return mgoutil.FindPage[*relation.GroupMemberModel](ctx, g.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.GroupMemberModel](ctx, g.coll, filter, pagination)
 }

 func (g *GroupMemberMgo) FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
 }

 func (g *GroupMemberMgo) TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error) {
-	return mgoutil.Count(ctx, g.coll, bson.M{"group_id": groupID})
+	return mongoutil.Count(ctx, g.coll, bson.M{"group_id": groupID})
 }

 func (g *GroupMemberMgo) FindUserManagedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
@@ -107,7 +107,7 @@ func (g *GroupMemberMgo) FindUserManagedGroupID(ctx context.Context, userID stri
 			"$in": []int{constant.GroupOwner, constant.GroupAdmin},
 		},
 	}
-	return mgoutil.Find[string](ctx, g.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
 }

 func (g *GroupMemberMgo) IsUpdateRoleLevel(data map[string]any) bool {
@@ -17,10 +17,10 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -46,29 +46,29 @@ type GroupRequestMgo struct {
 }

 func (g *GroupRequestMgo) Create(ctx context.Context, groupRequests []*relation.GroupRequestModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groupRequests)
+	return mongoutil.InsertMany(ctx, g.coll, groupRequests)
 }

 func (g *GroupRequestMgo) Delete(ctx context.Context, groupID string, userID string) (err error) {
-	return mgoutil.DeleteOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.DeleteOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }

 func (g *GroupRequestMgo) UpdateHandler(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32) (err error) {
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": bson.M{"handle_msg": handledMsg, "handle_result": handleResult}}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": bson.M{"handle_msg": handledMsg, "handle_result": handleResult}}, true)
 }

 func (g *GroupRequestMgo) Take(ctx context.Context, groupID string, userID string) (groupRequest *relation.GroupRequestModel, err error) {
-	return mgoutil.FindOne[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.FindOne[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }

 func (g *GroupRequestMgo) FindGroupRequests(ctx context.Context, groupID string, userIDs []string) ([]*relation.GroupRequestModel, error) {
-	return mgoutil.Find[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": bson.M{"$in": userIDs}})
 }

 func (g *GroupRequestMgo) Page(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, groups []*relation.GroupRequestModel, err error) {
-	return mgoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"user_id": userID}, pagination)
+	return mongoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"user_id": userID}, pagination)
 }

 func (g *GroupRequestMgo) PageGroup(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (total int64, groups []*relation.GroupRequestModel, err error) {
-	return mgoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}}, pagination)
+	return mongoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}}, pagination)
 }
@@ -18,9 +18,9 @@ import (
 	"context"
 	"time"

-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -57,7 +57,7 @@ type LogMgo struct {
 }

 func (l *LogMgo) Create(ctx context.Context, log []*relation.LogModel) error {
-	return mgoutil.InsertMany(ctx, l.coll, log)
+	return mongoutil.InsertMany(ctx, l.coll, log)
 }

 func (l *LogMgo) Search(ctx context.Context, keyword string, start time.Time, end time.Time, pagination pagination.Pagination) (int64, []*relation.LogModel, error) {
@@ -65,19 +65,19 @@ func (l *LogMgo) Search(ctx context.Context, keyword string, start time.Time, en
 	if keyword != "" {
 		filter["user_id"] = bson.M{"$regex": keyword}
 	}
-	return mgoutil.FindPage[*relation.LogModel](ctx, l.coll, filter, pagination, options.Find().SetSort(bson.M{"create_time": -1}))
+	return mongoutil.FindPage[*relation.LogModel](ctx, l.coll, filter, pagination, options.Find().SetSort(bson.M{"create_time": -1}))
 }

 func (l *LogMgo) Delete(ctx context.Context, logID []string, userID string) error {
 	if userID == "" {
-		return mgoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}})
+		return mongoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}})
 	}
-	return mgoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}, "user_id": userID})
+	return mongoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}, "user_id": userID})
 }

 func (l *LogMgo) Get(ctx context.Context, logIDs []string, userID string) ([]*relation.LogModel, error) {
 	if userID == "" {
-		return mgoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}})
+		return mongoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}})
 	}
-	return mgoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}, "user_id": userID})
+	return mongoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}, "user_id": userID})
 }
@@ -0,0 +1,898 @@
+package mgo
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/protocol/msg"
+	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/utils/jsonutil"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func NewMsgMongo(db *mongo.Database) (relation.MsgDocModelInterface, error) {
+	coll := db.Collection(new(relation.MsgDocModel).TableName())
+	_, err := coll.Indexes().CreateOne(context.Background(), mongo.IndexModel{
+		Keys: bson.D{
+			{Key: "doc_id", Value: 1},
+		},
+		Options: options.Index().SetUnique(true),
+	})
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	return &MsgMgo{coll: coll}, nil
+}
+
+type MsgMgo struct {
+	coll  *mongo.Collection
+	model relation.MsgDocModel
+}
+
+func (m *MsgMgo) PushMsgsToDoc(ctx context.Context, docID string, msgsToMongo []relation.MsgInfoModel) error {
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{"$push": bson.M{"msgs": bson.M{"$each": msgsToMongo}}}
+	return mongoutil.UpdateOne(ctx, m.coll, filter, update, false)
+}
+
+func (m *MsgMgo) Create(ctx context.Context, model *relation.MsgDocModel) error {
+	return mongoutil.InsertMany(ctx, m.coll, []*relation.MsgDocModel{model})
+}
+
+func (m *MsgMgo) UpdateMsg(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
+	var field string
+	if key == "" {
+		field = fmt.Sprintf("msgs.%d", index)
+	} else {
+		field = fmt.Sprintf("msgs.%d.%s", index, key)
+	}
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{"$set": bson.M{field: value}}
+	return mongoutil.UpdateOneResult(ctx, m.coll, filter, update)
+}
+
+func (m *MsgMgo) PushUnique(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
+	var field string
+	if key == "" {
+		field = fmt.Sprintf("msgs.%d", index)
+	} else {
+		field = fmt.Sprintf("msgs.%d.%s", index, key)
+	}
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{
+		"$addToSet": bson.M{
+			field: bson.M{"$each": value},
+		},
+	}
+	return mongoutil.UpdateOneResult(ctx, m.coll, filter, update)
+}
+
+func (m *MsgMgo) UpdateMsgContent(ctx context.Context, docID string, index int64, msg []byte) error {
+	filter := bson.M{"doc_id": docID}
+	update := bson.M{"$set": bson.M{fmt.Sprintf("msgs.%d.msg", index): msg}}
+	return mongoutil.UpdateOne(ctx, m.coll, filter, update, false)
+}
+
+func (m *MsgMgo) IsExistDocID(ctx context.Context, docID string) (bool, error) {
+	return mongoutil.Exist(ctx, m.coll, bson.M{"doc_id": docID})
+}
+
+func (m *MsgMgo) FindOneByDocID(ctx context.Context, docID string) (*relation.MsgDocModel, error) {
+	return mongoutil.FindOne[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": docID})
+}
+
+func (m *MsgMgo) GetMsgBySeqIndexIn1Doc(ctx context.Context, userID, docID string, seqs []int64) ([]*relation.MsgInfoModel, error) {
+	indexs := make([]int64, 0, len(seqs))
+	for _, seq := range seqs {
+		indexs = append(indexs, m.model.GetMsgIndex(seq))
+	}
+	pipeline := mongo.Pipeline{
+		bson.D{{Key: "$match", Value: bson.D{
+			{Key: "doc_id", Value: docID},
+		}}},
+		bson.D{{Key: "$project", Value: bson.D{
+			{Key: "_id", Value: 0},
+			{Key: "doc_id", Value: 1},
+			{Key: "msgs", Value: bson.D{
+				{Key: "$map", Value: bson.D{
+					{Key: "input", Value: indexs},
+					{Key: "as", Value: "index"},
+					{Key: "in", Value: bson.D{
+						{Key: "$let", Value: bson.D{
+							{Key: "vars", Value: bson.D{
+								{Key: "currentMsg", Value: bson.D{
+									{Key: "$arrayElemAt", Value: bson.A{"$msgs", "$$index"}},
+								}},
+							}},
+							{Key: "in", Value: bson.D{
+								{Key: "$cond", Value: bson.D{
+									{Key: "if", Value: bson.D{
+										{Key: "$in", Value: bson.A{userID, "$$currentMsg.del_list"}},
+									}},
+									{Key: "then", Value: nil},
+									{Key: "else", Value: "$$currentMsg"},
+								}},
+							}},
+						}},
+					}},
+				}},
+			}},
+		}}},
+		bson.D{{Key: "$project", Value: bson.D{
+			{Key: "msgs.del_list", Value: 0},
+		}}},
+	}
+	msgDocModel, err := mongoutil.Aggregate[*relation.MsgDocModel](ctx, m.coll, pipeline)
+	if err != nil {
+		return nil, err
+	}
+	if len(msgDocModel) == 0 {
+		return nil, errs.Wrap(mongo.ErrNoDocuments)
+	}
+	msgs := make([]*relation.MsgInfoModel, 0, len(msgDocModel[0].Msg))
+	for i := range msgDocModel[0].Msg {
+		msg := msgDocModel[0].Msg[i]
+		if msg == nil || msg.Msg == nil {
+			continue
+		}
+		if msg.Revoke != nil {
+			revokeContent := sdkws.MessageRevokedContent{
+				RevokerID:                   msg.Revoke.UserID,
+				RevokerRole:                 msg.Revoke.Role,
+				ClientMsgID:                 msg.Msg.ClientMsgID,
+				RevokerNickname:             msg.Revoke.Nickname,
+				RevokeTime:                  msg.Revoke.Time,
+				SourceMessageSendTime:       msg.Msg.SendTime,
+				SourceMessageSendID:         msg.Msg.SendID,
+				SourceMessageSenderNickname: msg.Msg.SenderNickname,
+				SessionType:                 msg.Msg.SessionType,
+				Seq:                         msg.Msg.Seq,
+				Ex:                          msg.Msg.Ex,
+			}
+			data, err := jsonutil.JsonMarshal(&revokeContent)
+			if err != nil {
+				return nil, errs.WrapMsg(err, fmt.Sprintf("docID is %s, seqs is %v", docID, seqs))
+			}
+			elem := sdkws.NotificationElem{
+				Detail: string(data),
+			}
+			content, err := jsonutil.JsonMarshal(&elem)
+			if err != nil {
+				return nil, errs.WrapMsg(err, fmt.Sprintf("docID is %s, seqs is %v", docID, seqs))
+			}
+			msg.Msg.ContentType = constant.MsgRevokeNotification
+			msg.Msg.Content = string(content)
+		}
+		msgs = append(msgs, msg)
+	}
+	return msgs, nil
+}
+
+func (m *MsgMgo) GetNewestMsg(ctx context.Context, conversationID string) (*relation.MsgInfoModel, error) {
+	for skip := int64(0); ; skip++ {
+		msgDocModel, err := m.GetMsgDocModelByIndex(ctx, conversationID, skip, -1)
+		if err != nil {
+			return nil, err
+		}
+		for i := len(msgDocModel.Msg) - 1; i >= 0; i-- {
+			if msgDocModel.Msg[i].Msg != nil {
+				return msgDocModel.Msg[i], nil
+			}
+		}
+	}
+}
+
+func (m *MsgMgo) GetOldestMsg(ctx context.Context, conversationID string) (*relation.MsgInfoModel, error) {
+	for skip := int64(0); ; skip++ {
+		msgDocModel, err := m.GetMsgDocModelByIndex(ctx, conversationID, skip, 1)
+		if err != nil {
+			return nil, err
+		}
+		for i, v := range msgDocModel.Msg {
+			if v.Msg != nil {
+				return msgDocModel.Msg[i], nil
+			}
+		}
+	}
+}
+
+func (m *MsgMgo) DeleteDocs(ctx context.Context, docIDs []string) error {
+	if len(docIDs) == 0 {
+		return nil
+	}
+	return mongoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": bson.M{"$in": docIDs}})
+}
+
+func (m *MsgMgo) GetMsgDocModelByIndex(ctx context.Context, conversationID string, index, sort int64) (*relation.MsgDocModel, error) {
+	if sort != 1 && sort != -1 {
+		return nil, errs.ErrArgs.WrapMsg("mongo sort must be 1 or -1")
+	}
+	opt := options.Find().SetLimit(1).SetSkip(index).SetSort(bson.M{"doc_id": sort}).SetLimit(1)
+	filter := bson.M{"doc_id": primitive.Regex{Pattern: fmt.Sprintf("^%s:", conversationID)}}
+	msgs, err := mongoutil.Find[*relation.MsgDocModel](ctx, m.coll, filter, opt)
+	if err != nil {
+		return nil, err
+	}
+	if len(msgs) > 0 {
+		return msgs[0], nil
+	}
+	return nil, errs.Wrap(relation.ErrMsgListNotExist)
+}
+
+func (m *MsgMgo) DeleteMsgsInOneDocByIndex(ctx context.Context, docID string, indexes []int) error {
+	update := bson.M{
+		"$set": bson.M{},
+	}
+	for _, index := range indexes {
+		update["$set"].(bson.M)[fmt.Sprintf("msgs.%d", index)] = bson.M{
+			"msg": nil,
+		}
+	}
+	_, err := mongoutil.UpdateMany(ctx, m.coll, bson.M{"doc_id": docID}, update)
+	return err
+}
+
+func (m *MsgMgo) MarkSingleChatMsgsAsRead(ctx context.Context, userID string, docID string, indexes []int64) error {
+	var updates []mongo.WriteModel
+	for _, index := range indexes {
+		filter := bson.M{
+			"doc_id": docID,
+			fmt.Sprintf("msgs.%d.msg.send_id", index): bson.M{
+				"$ne": userID,
+			},
+		}
+		update := bson.M{
+			"$set": bson.M{
+				fmt.Sprintf("msgs.%d.is_read", index): true,
+			},
+		}
+		updateModel := mongo.NewUpdateManyModel().
+			SetFilter(filter).
+			SetUpdate(update)
+		updates = append(updates, updateModel)
+	}
+	if _, err := m.coll.BulkWrite(ctx, updates); err != nil {
+		return errs.WrapMsg(err, fmt.Sprintf("docID is %s, indexes is %v", docID, indexes))
+	}
+	return nil
+}
+
+func (m *MsgMgo) SearchMessage(ctx context.Context, req *msg.SearchMessageReq) (int32, []*relation.MsgInfoModel, error) {
+	var pipe mongo.Pipeline
+	condition := bson.A{}
+	if req.SendTime != "" {
+		// Changed to keyed fields for bson.M to avoid govet errors
+		condition = append(condition, bson.M{"$eq": bson.A{bson.M{"$dateToString": bson.M{"format": "%Y-%m-%d", "date": bson.M{"$toDate": "$$item.msg.send_time"}}}, req.SendTime}})
+	}
+	if req.ContentType != 0 {
+		condition = append(condition, bson.M{"$eq": bson.A{"$$item.msg.content_type", req.ContentType}})
+	}
+	if req.SessionType != 0 {
+		condition = append(condition, bson.M{"$eq": bson.A{"$$item.msg.session_type", req.SessionType}})
+	}
+	if req.RecvID != "" {
+		condition = append(condition, bson.M{"$regexFind": bson.M{"input": "$$item.msg.recv_id", "regex": req.RecvID}})
+	}
+	if req.SendID != "" {
+		condition = append(condition, bson.M{"$regexFind": bson.M{"input": "$$item.msg.send_id", "regex": req.SendID}})
+	}
+
+	or := bson.A{
+		bson.M{"doc_id": bson.M{"$regex": "^si_", "$options": "i"}},
+		bson.M{"doc_id": bson.M{"$regex": "^g_", "$options": "i"}},
+		bson.M{"doc_id": bson.M{"$regex": "^sg_", "$options": "i"}},
+	}
+
+	// Use bson.D with keyed fields to specify the order explicitly
+	pipe = mongo.Pipeline{
+		{{"$match", bson.D{{Key: "$or", Value: or}}}},
+		{{"$project", bson.D{
+			{Key: "msgs", Value: bson.D{
+				{Key: "$filter", Value: bson.D{
+					{Key: "input", Value: "$msgs"},
+					{Key: "as", Value: "item"},
+					{Key: "cond", Value: bson.D{{Key: "$and", Value: condition}}},
+				}},
+			}},
+			{Key: "doc_id", Value: 1},
+		}}},
+		{{"$unwind", bson.M{"path": "$msgs"}}},
+		{{"$sort", bson.M{"msgs.msg.send_time": -1}}},
+	}
+	type docModel struct {
+		DocID string                 `bson:"doc_id"`
+		Msg   *relation.MsgInfoModel `bson:"msgs"`
+	}
+	msgsDocs, err := mongoutil.Aggregate[*docModel](ctx, m.coll, pipe)
+	if err != nil {
+		return 0, nil, err
+	}
+	msgs := make([]*relation.MsgInfoModel, 0)
+	for _, doc := range msgsDocs {
+		msgInfo := doc.Msg
+		if msgInfo == nil || msgInfo.Msg == nil {
+			continue
+		}
+		if msgInfo.Revoke != nil {
+			revokeContent := sdkws.MessageRevokedContent{
+				RevokerID:                   msgInfo.Revoke.UserID,
+				RevokerRole:                 msgInfo.Revoke.Role,
+				ClientMsgID:                 msgInfo.Msg.ClientMsgID,
+				RevokerNickname:             msgInfo.Revoke.Nickname,
+				RevokeTime:                  msgInfo.Revoke.Time,
+				SourceMessageSendTime:       msgInfo.Msg.SendTime,
+				SourceMessageSendID:         msgInfo.Msg.SendID,
+				SourceMessageSenderNickname: msgInfo.Msg.SenderNickname,
+				SessionType:                 msgInfo.Msg.SessionType,
+				Seq:                         msgInfo.Msg.Seq,
+				Ex:                          msgInfo.Msg.Ex,
+			}
+			data, err := jsonutil.JsonMarshal(&revokeContent)
+			if err != nil {
+				return 0, nil, errs.WrapMsg(err, "json.Marshal revokeContent")
+			}
+			elem := sdkws.NotificationElem{Detail: string(data)}
+			content, err := jsonutil.JsonMarshal(&elem)
+			if err != nil {
+				return 0, nil, errs.WrapMsg(err, "json.Marshal elem")
+			}
+			msgInfo.Msg.ContentType = constant.MsgRevokeNotification
+			msgInfo.Msg.Content = string(content)
+		}
+		msgs = append(msgs, msgInfo)
+	}
+	start := (req.Pagination.PageNumber - 1) * req.Pagination.ShowNumber
+	n := int32(len(msgs))
+	if start >= n {
+		return n, []*relation.MsgInfoModel{}, nil
+	}
+	if start+req.Pagination.ShowNumber < n {
+		msgs = msgs[start : start+req.Pagination.ShowNumber]
+	} else {
+		msgs = msgs[start:]
+	}
+	return n, msgs, nil
+}
+
+func (m *MsgMgo) RangeUserSendCount(ctx context.Context, start time.Time, end time.Time, group bool, ase bool, pageNumber int32, showNumber int32) (msgCount int64, userCount int64, users []*relation.UserCount, dateCount map[string]int64, err error) {
+	var sort int
+	if ase {
+		sort = 1
+	} else {
+		sort = -1
+	}
+	type Result struct {
+		MsgCount  int64 `bson:"msg_count"`
+		UserCount int64 `bson:"user_count"`
+		Users     []struct {
+			UserID string `bson:"_id"`
+			Count  int64  `bson:"count"`
+		} `bson:"users"`
+		Dates []struct {
+			Date  string `bson:"_id"`
+			Count int64  `bson:"count"`
+		} `bson:"dates"`
+	}
+	or := bson.A{
+		bson.M{
+			"doc_id": bson.M{
+				"$regex":   "^si_",
+				"$options": "i",
+			},
+		},
+	}
+	if group {
+		or = append(or,
+			bson.M{
+				"doc_id": bson.M{
+					"$regex":   "^g_",
+					"$options": "i",
+				},
+			},
+			bson.M{
+				"doc_id": bson.M{
+					"$regex":   "^sg_",
+					"$options": "i",
+				},
+			},
+		)
+	}
+	pipeline := bson.A{
+		bson.M{
+			"$match": bson.M{
+				"$and": bson.A{
+					bson.M{
+						"msgs.msg.send_time": bson.M{
+							"$gte": start.UnixMilli(),
+							"$lt":  end.UnixMilli(),
+						},
+					},
+					bson.M{
+						"$or": or,
+					},
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"msgs": bson.M{
+					"$filter": bson.M{
+						"input": "$msgs",
+						"as":    "item",
+						"cond": bson.M{
+							"$and": bson.A{
+								bson.M{
+									"$gte": bson.A{
+										"$$item.msg.send_time", start.UnixMilli(),
+									},
+								},
+								bson.M{
+									"$lt": bson.A{
+										"$$item.msg.send_time", end.UnixMilli(),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id": 0,
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"result": bson.M{
+					"$map": bson.M{
+						"input": "$msgs",
+						"as":    "item",
+						"in": bson.M{
+							"user_id": "$$item.msg.send_id",
+							"send_date": bson.M{
+								"$dateToString": bson.M{
+									"format": "%Y-%m-%d",
+									"date": bson.M{
+										"$toDate": "$$item.msg.send_time", // Millisecond timestamp
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		bson.M{
+			"$unwind": "$result",
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": "$result.send_date",
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"original": bson.M{
+					"$push": "$$ROOT",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": "$$ROOT",
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id":            0,
+				"count":          0,
+				"dates.original": 0,
+			},
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": nil,
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"dates": bson.M{
+					"$push": "$dates",
+				},
+				"original": bson.M{
+					"$push": "$original",
+				},
+			},
+		},
+		bson.M{
+			"$unwind": "$original",
+		},
+		bson.M{
+			"$unwind": "$original",
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": "$original.result.user_id",
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"original": bson.M{
+					"$push": "$dates",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": bson.M{
+					"$arrayElemAt": bson.A{"$original", 0},
+				},
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"original": 0,
+			},
+		},
+		bson.M{
+			"$sort": bson.M{
+				"count": sort,
+			},
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": nil,
+				"user_count": bson.M{
+					"$sum": 1,
+				},
+				"users": bson.M{
+					"$push": "$$ROOT",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": bson.M{
+					"$arrayElemAt": bson.A{"$users", 0},
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": "$dates.dates",
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id":         0,
+				"users.dates": 0,
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"msg_count": bson.M{
+					"$sum": "$users.count",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"users": bson.M{
+					"$slice": bson.A{"$users", pageNumber - 1, showNumber},
+				},
+			},
+		},
+	}
+	result, err := mongoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
+	if err != nil {
+		return 0, 0, nil, nil, err
+	}
+	if len(result) == 0 {
+		return 0, 0, nil, nil, errs.Wrap(err)
+	}
+	users = make([]*relation.UserCount, len(result[0].Users))
+	for i, r := range result[0].Users {
+		users[i] = &relation.UserCount{
+			UserID: r.UserID,
+			Count:  r.Count,
+		}
+	}
+	dateCount = make(map[string]int64)
+	for _, r := range result[0].Dates {
+		dateCount[r.Date] = r.Count
+	}
+	return result[0].MsgCount, result[0].UserCount, users, dateCount, nil
+}
+
+func (m *MsgMgo) RangeGroupSendCount(ctx context.Context, start time.Time, end time.Time, ase bool, pageNumber int32, showNumber int32) (msgCount int64, userCount int64, groups []*relation.GroupCount, dateCount map[string]int64, err error) {
+	var sort int
+	if ase {
+		sort = 1
+	} else {
+		sort = -1
+	}
+	type Result struct {
+		MsgCount  int64 `bson:"msg_count"`
+		UserCount int64 `bson:"user_count"`
+		Groups    []struct {
+			GroupID string `bson:"_id"`
+			Count   int64  `bson:"count"`
+		} `bson:"groups"`
+		Dates []struct {
+			Date  string `bson:"_id"`
+			Count int64  `bson:"count"`
+		} `bson:"dates"`
+	}
+	pipeline := bson.A{
+		bson.M{
+			"$match": bson.M{
+				"$and": bson.A{
+					bson.M{
+						"msgs.msg.send_time": bson.M{
+							"$gte": start.UnixMilli(),
+							"$lt":  end.UnixMilli(),
+						},
+					},
+					bson.M{
+						"$or": bson.A{
+							bson.M{
+								"doc_id": bson.M{
+									"$regex":   "^g_",
+									"$options": "i",
+								},
+							},
+							bson.M{
+								"doc_id": bson.M{
+									"$regex":   "^sg_",
+									"$options": "i",
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"msgs": bson.M{
+					"$filter": bson.M{
+						"input": "$msgs",
+						"as":    "item",
+						"cond": bson.M{
+							"$and": bson.A{
+								bson.M{
+									"$gte": bson.A{
+										"$$item.msg.send_time", start.UnixMilli(),
+									},
+								},
+								bson.M{
+									"$lt": bson.A{
+										"$$item.msg.send_time", end.UnixMilli(),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id": 0,
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"result": bson.M{
+					"$map": bson.M{
+						"input": "$msgs",
+						"as":    "item",
+						"in": bson.M{
+							"group_id": "$$item.msg.group_id",
+							"send_date": bson.M{
+								"$dateToString": bson.M{
+									"format": "%Y-%m-%d",
+									"date": bson.M{
+										"$toDate": "$$item.msg.send_time", // Millisecond timestamp
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		bson.M{
+			"$unwind": "$result",
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": "$result.send_date",
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"original": bson.M{
+					"$push": "$$ROOT",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": "$$ROOT",
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id":            0,
+				"count":          0,
+				"dates.original": 0,
+			},
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": nil,
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"dates": bson.M{
+					"$push": "$dates",
+				},
+				"original": bson.M{
+					"$push": "$original",
+				},
+			},
+		},
+		bson.M{
+			"$unwind": "$original",
+		},
+		bson.M{
+			"$unwind": "$original",
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": "$original.result.group_id",
+				"count": bson.M{
+					"$sum": 1,
+				},
+				"original": bson.M{
+					"$push": "$dates",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": bson.M{
+					"$arrayElemAt": bson.A{"$original", 0},
+				},
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"original": 0,
+			},
+		},
+		bson.M{
+			"$sort": bson.M{
+				"count": sort,
+			},
+		},
+		bson.M{
+			"$group": bson.M{
+				"_id": nil,
+				"user_count": bson.M{
+					"$sum": 1,
+				},
+				"groups": bson.M{
+					"$push": "$$ROOT",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": bson.M{
+					"$arrayElemAt": bson.A{"$groups", 0},
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"dates": "$dates.dates",
+			},
+		},
+		bson.M{
+			"$project": bson.M{
+				"_id":          0,
+				"groups.dates": 0,
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"msg_count": bson.M{
+					"$sum": "$groups.count",
+				},
+			},
+		},
+		bson.M{
+			"$addFields": bson.M{
+				"groups": bson.M{
+					"$slice": bson.A{"$groups", pageNumber - 1, showNumber},
+				},
+			},
+		},
+	}
+	result, err := mongoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
+	if err != nil {
+		return 0, 0, nil, nil, err
+	}
+	if len(result) == 0 {
+		return 0, 0, nil, nil, errs.Wrap(err)
+	}
+	groups = make([]*relation.GroupCount, len(result[0].Groups))
+	for i, r := range result[0].Groups {
+		groups[i] = &relation.GroupCount{
+			GroupID: r.GroupID,
+			Count:   r.Count,
+		}
+	}
+	dateCount = make(map[string]int64)
+	for _, r := range result[0].Dates {
+		dateCount[r.Date] = r.Count
+	}
+	return result[0].MsgCount, result[0].UserCount, groups, dateCount, nil
+}
+
+func (m *MsgMgo) ConvertMsgsDocLen(ctx context.Context, conversationIDs []string) {
+	for _, conversationID := range conversationIDs {
+		regex := primitive.Regex{Pattern: fmt.Sprintf("^%s:", conversationID)}
+		msgDocs, err := mongoutil.Find[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": regex})
+		if err != nil {
+			log.ZError(ctx, "convertAll find msg doc failed", err, "conversationID", conversationID)
+			continue
+		}
+		if len(msgDocs) < 1 {
+			continue
+		}
+		log.ZDebug(ctx, "msg doc convert", "conversationID", conversationID, "len(msgDocs)", len(msgDocs))
+		if len(msgDocs[0].Msg) == int(m.model.GetSingleGocMsgNum5000()) {
+			if err := mongoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": regex}); err != nil {
+				log.ZError(ctx, "convertAll delete many failed", err, "conversationID", conversationID)
+				continue
+			}
+			var newMsgDocs []any
+			for _, msgDoc := range msgDocs {
+				if int64(len(msgDoc.Msg)) == m.model.GetSingleGocMsgNum() {
+					continue
+				}
+				var index int64
+				for index < int64(len(msgDoc.Msg)) {
+					msg := msgDoc.Msg[index]
+					if msg != nil && msg.Msg != nil {
+						msgDocModel := relation.MsgDocModel{DocID: m.model.GetDocID(conversationID, msg.Msg.Seq)}
+						end := index + m.model.GetSingleGocMsgNum()
+						if int(end) >= len(msgDoc.Msg) {
+							msgDocModel.Msg = msgDoc.Msg[index:]
+						} else {
+							msgDocModel.Msg = msgDoc.Msg[index:end]
+						}
+						newMsgDocs = append(newMsgDocs, msgDocModel)
+						index = end
+					} else {
+						break
+					}
+				}
+			}
+			if err = mongoutil.InsertMany(ctx, m.coll, newMsgDocs); err != nil {
+				log.ZError(ctx, "convertAll insert many failed", err, "conversationID", conversationID, "len(newMsgDocs)", len(newMsgDocs))
+			} else {
+				log.ZDebug(ctx, "msg doc convert", "conversationID", conversationID, "len(newMsgDocs)", len(newMsgDocs))
+			}
+		}
+	}
+}
@@ -17,9 +17,9 @@ package mgo
 import (
 	"context"

-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -54,16 +54,16 @@ func (o *S3Mongo) SetObject(ctx context.Context, obj *relation.ObjectModel) erro
 		"group":        obj.Group,
 		"create_time":  obj.CreateTime,
 	}
-	return mgoutil.UpdateOne(ctx, o.coll, filter, bson.M{"$set": update}, false, options.Update().SetUpsert(true))
+	return mongoutil.UpdateOne(ctx, o.coll, filter, bson.M{"$set": update}, false, options.Update().SetUpsert(true))
 }

 func (o *S3Mongo) Take(ctx context.Context, engine string, name string) (*relation.ObjectModel, error) {
 	if engine == "" {
-		return mgoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name})
+		return mongoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name})
 	}
-	return mgoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name, "engine": engine})
+	return mongoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name, "engine": engine})
 }

 func (o *S3Mongo) Delete(ctx context.Context, engine string, name string) error {
-	return mgoutil.DeleteOne(ctx, o.coll, bson.M{"name": name, "engine": engine})
+	return mongoutil.DeleteOne(ctx, o.coll, bson.M{"name": name, "engine": engine})
 }
@@ -0,0 +1,188 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mgo
+
+import (
+	"context"
+
+	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/errs"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// prefixes and suffixes.
+const (
+	SubscriptionPrefix = "subscription_prefix"
+	SubscribedPrefix   = "subscribed_prefix"
+)
+
+// MaximumSubscription Maximum number of subscriptions.
+const (
+	MaximumSubscription = 3000
+)
+
+func NewUserMongoDriver(database *mongo.Database) relation.SubscribeUserModelInterface {
+	return &UserMongoDriver{
+		userCollection: database.Collection(relation.SubscribeUser),
+	}
+}
+
+type UserMongoDriver struct {
+	userCollection *mongo.Collection
+}
+
+// AddSubscriptionList Subscriber's handling of thresholds.
+func (u *UserMongoDriver) AddSubscriptionList(ctx context.Context, userID string, userIDList []string) error {
+	// Check the number of lists in the key.
+	pipeline := mongo.Pipeline{
+		{{"$match", bson.D{{"user_id", SubscriptionPrefix + userID}}}},
+		{{"$project", bson.D{{"count", bson.D{{"$size", "$user_id_list"}}}}}},
+	}
+	// perform aggregate operations
+	cursor, err := u.userCollection.Aggregate(ctx, pipeline)
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	defer cursor.Close(ctx)
+	var cnt struct {
+		Count int `bson:"count"`
+	}
+	// iterate over aggregated results
+	for cursor.Next(ctx) {
+		err = cursor.Decode(&cnt)
+		if err != nil {
+			return errs.Wrap(err)
+		}
+	}
+	var newUserIDList []string
+	// If the threshold is exceeded, pop out the previous MaximumSubscription - len(userIDList) and insert it.
+	if cnt.Count+len(userIDList) > MaximumSubscription {
+		newUserIDList, err = u.GetAllSubscribeList(ctx, userID)
+		if err != nil {
+			return err
+		}
+		newUserIDList = newUserIDList[MaximumSubscription-len(userIDList):]
+		_, err = u.userCollection.UpdateOne(
+			ctx,
+			bson.M{"user_id": SubscriptionPrefix + userID},
+			bson.M{"$set": bson.M{"user_id_list": newUserIDList}},
+		)
+		if err != nil {
+			return err
+		}
+		// Another way to subscribe to N before pop,Delete after testing
+		/*for i := 1; i <= MaximumSubscription-len(userIDList); i++ {
+			_, err := u.userCollection.UpdateOne(
+				ctx,
+				bson.M{"user_id": SubscriptionPrefix + userID},
+				bson.M{SubscriptionPrefix + userID: bson.M{"$pop": -1}},
+			)
+			if err != nil {
+				return err
+			}
+		}*/
+	}
+	upsert := true
+	opts := &options.UpdateOptions{
+		Upsert: &upsert,
+	}
+	_, err = u.userCollection.UpdateOne(
+		ctx,
+		bson.M{"user_id": SubscriptionPrefix + userID},
+		bson.M{"$addToSet": bson.M{"user_id_list": bson.M{"$each": userIDList}}},
+		opts,
+	)
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	for _, user := range userIDList {
+		_, err = u.userCollection.UpdateOne(
+			ctx,
+			bson.M{"user_id": SubscribedPrefix + user},
+			bson.M{"$addToSet": bson.M{"user_id_list": userID}},
+			opts,
+		)
+		if err != nil {
+			return errs.WrapMsg(err, "transaction failed")
+		}
+	}
+	return nil
+}
+
+// UnsubscriptionList Handling of unsubscribe.
+func (u *UserMongoDriver) UnsubscriptionList(ctx context.Context, userID string, userIDList []string) error {
+	_, err := u.userCollection.UpdateOne(
+		ctx,
+		bson.M{"user_id": SubscriptionPrefix + userID},
+		bson.M{"$pull": bson.M{"user_id_list": bson.M{"$in": userIDList}}},
+	)
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	err = u.RemoveSubscribedListFromUser(ctx, userID, userIDList)
+	if err != nil {
+		return errs.Wrap(err)
+	}
+	return nil
+}
+
+// RemoveSubscribedListFromUser Among the unsubscribed users, delete the user from the subscribed list.
+func (u *UserMongoDriver) RemoveSubscribedListFromUser(ctx context.Context, userID string, userIDList []string) error {
+	var err error
+	for _, userIDTemp := range userIDList {
+		_, err = u.userCollection.UpdateOne(
+			ctx,
+			bson.M{"user_id": SubscribedPrefix + userIDTemp},
+			bson.M{"$pull": bson.M{"user_id_list": userID}},
+		)
+	}
+	return errs.Wrap(err)
+}
+
+// GetAllSubscribeList Get all users subscribed by this user.
+func (u *UserMongoDriver) GetAllSubscribeList(ctx context.Context, userID string) (userIDList []string, err error) {
+	var user relation.SubscribeUserModel
+	cursor := u.userCollection.FindOne(
+		ctx,
+		bson.M{"user_id": SubscriptionPrefix + userID})
+	err = cursor.Decode(&user)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return []string{}, nil
+		} else {
+			return nil, errs.Wrap(err)
+		}
+	}
+	return user.UserIDList, nil
+}
+
+// GetSubscribedList Get the user subscribed by those users.
+func (u *UserMongoDriver) GetSubscribedList(ctx context.Context, userID string) (userIDList []string, err error) {
+	var user relation.SubscribeUserModel
+	cursor := u.userCollection.FindOne(
+		ctx,
+		bson.M{"user_id": SubscribedPrefix + userID})
+	err = cursor.Decode(&user)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return []string{}, nil
+		} else {
+			return nil, errs.Wrap(err)
+		}
+	}
+	return user.UserIDList, nil
+}
@@ -18,11 +18,11 @@ import (
 	"context"
 	"time"

-	"github.com/OpenIMSDK/protocol/user"
-	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/mgoutil"
-	"github.com/OpenIMSDK/tools/pagination"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/protocol/user"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/errs"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -48,34 +48,34 @@ type UserMgo struct {
 }

 func (u *UserMgo) Create(ctx context.Context, users []*relation.UserModel) error {
-	return mgoutil.InsertMany(ctx, u.coll, users)
+	return mongoutil.InsertMany(ctx, u.coll, users)
 }

 func (u *UserMgo) UpdateByMap(ctx context.Context, userID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, u.coll, bson.M{"user_id": userID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, u.coll, bson.M{"user_id": userID}, bson.M{"$set": args}, true)
 }

 func (u *UserMgo) Find(ctx context.Context, userIDs []string) (users []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"user_id": bson.M{"$in": userIDs}})
 }

 func (u *UserMgo) Take(ctx context.Context, userID string) (user *relation.UserModel, err error) {
-	return mgoutil.FindOne[*relation.UserModel](ctx, u.coll, bson.M{"user_id": userID})
+	return mongoutil.FindOne[*relation.UserModel](ctx, u.coll, bson.M{"user_id": userID})
 }

 func (u *UserMgo) TakeNotification(ctx context.Context, level int64) (user []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"app_manger_level": level})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"app_manger_level": level})
 }

 func (u *UserMgo) TakeByNickname(ctx context.Context, nickname string) (user []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"nickname": nickname})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"nickname": nickname})
 }

 func (u *UserMgo) Page(ctx context.Context, pagination pagination.Pagination) (count int64, users []*relation.UserModel, err error) {
-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, bson.M{}, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, bson.M{}, pagination)
 }

 func (u *UserMgo) PageFindUser(ctx context.Context, level1 int64, level2 int64, pagination pagination.Pagination) (count int64, users []*relation.UserModel, err error) {
@@ -86,7 +86,7 @@ func (u *UserMgo) PageFindUser(ctx context.Context, level1 int64, level2 int64,
 		},
 	}

-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
 }

 func (u *UserMgo) PageFindUserWithKeyword(
@@ -121,26 +121,26 @@ func (u *UserMgo) PageFindUserWithKeyword(
 	}

 	// Perform the paginated search
-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
 }

 func (u *UserMgo) GetAllUserID(ctx context.Context, pagination pagination.Pagination) (int64, []string, error) {
-	return mgoutil.FindPage[string](ctx, u.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.FindPage[string](ctx, u.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }

 func (u *UserMgo) Exist(ctx context.Context, userID string) (exist bool, err error) {
-	return mgoutil.Exist(ctx, u.coll, bson.M{"user_id": userID})
+	return mongoutil.Exist(ctx, u.coll, bson.M{"user_id": userID})
 }

 func (u *UserMgo) GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error) {
-	return mgoutil.FindOne[int](ctx, u.coll, bson.M{"user_id": userID}, options.FindOne().SetProjection(bson.M{"_id": 0, "global_recv_msg_opt": 1}))
+	return mongoutil.FindOne[int](ctx, u.coll, bson.M{"user_id": userID}, options.FindOne().SetProjection(bson.M{"_id": 0, "global_recv_msg_opt": 1}))
 }

 func (u *UserMgo) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) {
 	if before == nil {
-		return mgoutil.Count(ctx, u.coll, bson.M{})
+		return mongoutil.Count(ctx, u.coll, bson.M{})
 	}
-	return mgoutil.Count(ctx, u.coll, bson.M{"create_time": bson.M{"$lt": before}})
+	return mongoutil.Count(ctx, u.coll, bson.M{"create_time": bson.M{"$lt": before}})
 }

 func (u *UserMgo) AddUserCommand(ctx context.Context, userID string, Type int32, UUID string, value string, ex string) error {
@@ -308,7 +308,7 @@ func (u *UserMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time,
 		Date  string `bson:"_id"`
 		Count int64  `bson:"count"`
 	}
-	items, err := mgoutil.Aggregate[Item](ctx, u.coll, pipeline)
+	items, err := mongoutil.Aggregate[Item](ctx, u.coll, pipeline)
 	if err != nil {
 		return nil, err
 	}