fix api server update version

deployment/centrifugo.json

@@ -0,0 +1,44 @@
+{
+  "token_hmac_secret_key": "your-secret-key-change-in-production",
+  "admin_password": "admin",
+  "admin_secret": "admin-secret",
+  "api_key": "api-key",
+  "allowed_origins": [
+    "*"
+  ],
+  "log_level": "info",
+  "log_handler": "stdout",
+  "websocket_compression": true,
+  "websocket_read_buffer_size": 1024,
+  "websocket_write_buffer_size": 1024,
+  "namespaces": [
+    {
+      "name": "default",
+      "publish": true,
+      "subscribe_to_publish": true,
+      "presence": true,
+      "join_leave": true,
+      "history_size": 100,
+      "history_ttl": "300s"
+    },
+    {
+      "name": "room",
+      "publish": true,
+      "subscribe_to_publish": true,
+      "presence": true,
+      "join_leave": true,
+      "history_size": 100,
+      "history_ttl": "300s"
+    },
+    {
+      "name": "user",
+      "publish": false,
+      "subscribe_to_publish": false,
+      "presence": false,
+      "join_leave": false,
+      "history_size": 0,
+      "history_ttl": "0s"
+    }
+  ],
+  "redis_address": "redis:6379"
+}

deployment/docker-compose.yaml

@@ -27,7 +27,6 @@ services:
     restart: always
     ports:
       - "6379:6379"
-
   minio:
     image: minio/minio
     container_name: minio
@@ -39,3 +38,36 @@ services:
       MINIO_ROOT_PASSWORD: minioadmin # Replace with your desired root password
       # MINIO_DEFAULT_BUCKETS: mybucket # Optional: Create a default bucket on startup
     command: server /data --console-address ":9001" # Start MinIO server and specify console address
+  centrifugo:
+    image: centrifugo/centrifugo:v5
+    container_name: centrifugo
+    restart: always
+    ports:
+      - "8000:8000"  # HTTP API
+      - "8001:8001"  # WebSocket
+    volumes:
+      - ./centrifugo.json:/centrifugo/config.json:ro
+    command: centrifugo --config=/centrifugo/config.json
+    healthcheck:
+      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8000/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    depends_on:
+      - redis
+  cassandra:
+    image: cassandra:5.0.4
+    restart: always
+    ports:
+      - "9042:9042"
+    environment:
+      TZ: ${TIMEZONE:-UTC}
+      MAX_HEAP_SIZE: 4G
+      HEAP_NEWSIZE: 2G
+    healthcheck:
+      test: [ "CMD", "cqlsh", "-k", "sccflex" ]
+      interval: 10s
+      timeout: 10s
+      retries: 12
+    mem_limit: 8g        # <--- 單機 docker-compose up 時建議明確加這行
+    memswap_limit: 8g    # <--- 關掉 swap

gateway.json

@@ -1259,7 +1259,7 @@
       "url": "https://localhost:8888"
     }
   ],
-  "x-date": "2025-11-12 14:59:58",
+  "x-date": "2026-01-05 10:01:16",
   "x-description": "This is a go-doc generated swagger file.",
   "x-generator": "go-doc",
   "x-github": "https://github.com/danielchan-25/go-doc",

generate/database/cassandra/2026010611150001_chat_message.up.sql

@@ -0,0 +1,9 @@
+CREATE TABLE messages (
+      room_id     uuid,
+      bucket_day  date,
+      ts          bigint,
+      msg_id      uuid,
+      uid         text,
+      content     text,
+      PRIMARY KEY ((room_id, bucket_day), ts, msg_id)
+) WITH CLUSTERING ORDER BY (ts ASC);

generate/database/cassandra/2026010611150002_chat_message_dedupe.up.sql

@@ -0,0 +1,8 @@
+CREATE TABLE message_dedup (
+   room_id    uuid,
+   uid        text,
+   content_md5 text,
+   bucket_sec bigint,
+   PRIMARY KEY ((room_id, uid), bucket_sec, content_md5)
+) WITH default_time_to_live = 2;
+

go.mod

@@ -12,6 +12,7 @@ require (
 	github.com/go-playground/validator/v10 v10.28.0
 	github.com/gocql/gocql v1.7.0
 	github.com/golang-jwt/jwt/v4 v4.5.2
+	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
 	github.com/matcornic/hermes/v2 v2.1.0
 	github.com/minchao/go-mitake v1.0.0

go.sum

@@ -101,6 +101,8 @@ github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus=
 github.com/gocql/gocql v1.7.0/go.mod h1:vnlvXyFZeLBF0Wy+RS8hrOdbn0UWsWtdg07XJnFxZ+4=
 github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI=
 github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=

internal/config/config.go

@@ -108,4 +108,20 @@ type Config struct {
 		SecretKey        string
 		CloudFrontID     string
 	}
+
+	// Cassandra 配置
+	Cassandra struct {
+		Hosts     []string
+		Port      int
+		Keyspace  string
+		Username  string
+		Password  string
+		UseAuth   bool
+	}
+
+	// Centrifugo 配置
+	Centrifugo struct {
+		APIURL string
+		APIKey string
+	}
 }

internal/svc/chat.go

@@ -0,0 +1,67 @@
+package svc
+
+import (
+	"backend/internal/config"
+	"backend/pkg/chat/domain/usecase"
+	repo "backend/pkg/chat/repository"
+	uc "backend/pkg/chat/usecase"
+	"backend/pkg/library/cassandra"
+	"backend/pkg/library/centrifugo"
+	errs "backend/pkg/library/errors"
+	"fmt"
+)
+
+func MustMessageUseCase(c *config.Config, logger errs.Logger) usecase.MessageUseCase {
+	// 初始化 Cassandra DB
+	cassandraDB, err := initCassandraDB(c)
+	if err != nil {
+		panic(fmt.Sprintf("failed to initialize Cassandra DB: %v", err))
+	}
+
+	// 初始化 Message Repository
+	messageRepo := repo.MustMessageRepository(repo.MessageRepositoryParam{
+		DB:       cassandraDB,
+		Keyspace: c.Cassandra.Keyspace,
+	})
+
+	// 初始化 Room Repository
+	roomRepo := repo.MustRoomRepository(repo.RoomRepositoryParam{
+		DB:       cassandraDB,
+		Keyspace: c.Cassandra.Keyspace,
+	})
+
+	// 初始化 Centrifugo Client
+	msgClient := centrifugo.NewClientWithConfig(centrifugo.HighPerformanceConfig(c.Centrifugo.APIURL, c.Centrifugo.APIKey))
+
+	return uc.NewMessageUseCase(uc.MessageUseCaseParam{
+		MessageRepo: messageRepo,
+		RoomRepo:    roomRepo,
+		MsgClient:   msgClient,
+		Logger:      logger,
+	})
+}
+
+// initCassandraDB 初始化 Cassandra 資料庫連接
+func initCassandraDB(c *config.Config) (*cassandra.DB, error) {
+	if len(c.Cassandra.Hosts) == 0 {
+		return nil, fmt.Errorf("cassandra hosts are required")
+	}
+
+	opts := []cassandra.Option{
+		cassandra.WithHosts(c.Cassandra.Hosts...),
+	}
+
+	if c.Cassandra.Port > 0 {
+		opts = append(opts, cassandra.WithPort(c.Cassandra.Port))
+	}
+
+	if c.Cassandra.Keyspace != "" {
+		opts = append(opts, cassandra.WithKeyspace(c.Cassandra.Keyspace))
+	}
+
+	if c.Cassandra.UseAuth {
+		opts = append(opts, cassandra.WithAuth(c.Cassandra.Username, c.Cassandra.Password))
+	}
+
+	return cassandra.New(opts...)
+}

internal/svc/service_context.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/zeromicro/go-zero/core/logx"
 
+	chatUC "backend/pkg/chat/domain/usecase"
 	fileStorageUC "backend/pkg/fileStorage/domain/usecase"
 	vi "backend/pkg/library/validator"
 	memberUC "backend/pkg/member/domain/usecase"
@@ -31,6 +32,7 @@ type ServiceContext struct {
 	UserRoleUC     tokenUC.UserRoleUseCase
 	DeliveryUC     deliveryUC.DeliveryUseCase
 	FileStorageUC  fileStorageUC.FileStorageUseCase
+	MessageUC      chatUC.MessageUseCase
 	Redis          *redis.Redis
 	Logger         errs.Logger
 }
@@ -62,6 +64,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
 		Redis:          rds,
 		DeliveryUC:     MustDeliveryUseCase(&c, lgr),
 		FileStorageUC:  MustS3Storage(&c, lgr),
+		MessageUC:      MustMessageUseCase(&c, lgr),
 		Logger:         lgr,
 	}
 }

pkg/chat/domain/chat/room_role.go

@@ -0,0 +1,38 @@
+package chat
+
+// RoomRole 聊天室成員角色
+type RoomRole string
+
+const (
+	// RoomRoleMember 一般成員
+	RoomRoleMember RoomRole = "member"
+	// RoomRoleAdmin 管理員
+	RoomRoleAdmin RoomRole = "admin"
+	// RoomRoleOwner 擁有者
+	RoomRoleOwner RoomRole = "owner"
+)
+
+// String 返回角色的字串表示
+func (r RoomRole) String() string {
+	return string(r)
+}
+
+// IsValid 檢查角色是否有效
+func (r RoomRole) IsValid() bool {
+	switch r {
+	case RoomRoleMember, RoomRoleAdmin, RoomRoleOwner:
+		return true
+	default:
+		return false
+	}
+}
+
+// IsAdmin 檢查是否為管理員或擁有者
+func (r RoomRole) IsAdmin() bool {
+	return r == RoomRoleAdmin || r == RoomRoleOwner
+}
+
+// IsOwner 檢查是否為擁有者
+func (r RoomRole) IsOwner() bool {
+	return r == RoomRoleOwner
+}

pkg/chat/domain/entity/message.go

@@ -0,0 +1,23 @@
+package entity
+
+import (
+	"github.com/gocql/gocql"
+	"github.com/google/uuid"
+)
+
+// Message 對應 Cassandra 的 messages_by_room 表
+// Primary Key: (room_id, bucket_day)
+// Clustering Key: ts DESC
+type Message struct {
+	RoomID    gocql.UUID `db:"room_id" partition_key:"true"`
+	BucketDay string     `db:"bucket_day" partition_key:"true"` // yyyyMMdd
+	TS        int64      `db:"ts" clustering_key:"true"`        // timestamp
+	UID       string     `db:"uid"`
+	Content   string     `db:"content"`
+	MsgID     uuid.UUID  `db:"msg_id"`
+}
+
+// TableName 返回表名
+func (m Message) TableName() string {
+	return "messages_by_room"
+}

pkg/chat/domain/entity/message_dedup.go

@@ -0,0 +1,21 @@
+package entity
+
+import (
+	"github.com/gocql/gocql"
+)
+
+// MessageDedup 對應 Cassandra 的 message_dedup 表
+// Primary Key: ((room_id, uid), bucket_sec, content_md5)
+// TTL: 2 秒
+type MessageDedup struct {
+	RoomID    gocql.UUID `db:"room_id" partition_key:"true"`
+	UID       string     `db:"uid" partition_key:"true"`
+	BucketSec int64      `db:"bucket_sec" clustering_key:"true"` // Unix timestamp in seconds
+	ContentMD5 string     `db:"content_md5" clustering_key:"true"` // MD5 hash of content
+}
+
+// TableName 返回表名
+func (m MessageDedup) TableName() string {
+	return "message_dedup"
+}
+

pkg/chat/domain/entity/room.go

@@ -0,0 +1,59 @@
+package entity
+
+import "github.com/gocql/gocql"
+
+// Room 對應 Cassandra 的 room 表
+// Primary Key: (room_id)
+// 設計說明：存儲聊天室本身的基本資訊
+type Room struct {
+	RoomID    gocql.UUID `db:"room_id" partition_key:"true"`
+	Name      string     `db:"name"`       // 聊天室名稱
+	Status    string     `db:"status"`     // 狀態：active, archived, deleted
+	CreatedAt int64      `db:"created_at"` // 創建時間
+	UpdatedAt int64      `db:"updated_at"` // 更新時間
+}
+
+// TableName 返回表名
+func (r Room) TableName() string {
+	return "room"
+}
+
+// RoomMember 對應 Cassandra 的 room_member 表
+// Primary Key: (room_id)
+// Clustering Key: uid
+// 設計說明：
+// - room_id 作為 partition key，可以高效地查詢/刪除整個聊天室的所有成員
+// - uid 作為 clustering key，可以高效地查詢/刪除特定成員
+// - 支援三種操作：
+//  1. 刪除整個聊天室：刪除整個 partition（需要查詢後批量刪除或使用原生 CQL）
+//  2. 刪除特定成員：使用 Delete(roomID, uid)
+//  3. 查詢聊天室所有成員：使用 Query().Where(Eq("room_id", roomID)).Scan()
+type RoomMember struct {
+	RoomID   gocql.UUID `db:"room_id" partition_key:"true"`
+	UID      string     `db:"uid" clustering_key:"true"`
+	Role     string     `db:"role"`      // Role 角色：member（一般成員）、admin（管理員）、owner（擁有者）等
+	JoinedAt int64      `db:"joined_at"` // JoinedAt 加入時間（可選，用於記錄加入時間）
+}
+
+// TableName 返回表名
+func (m RoomMember) TableName() string {
+	return "room_member"
+}
+
+// UserRoom 對應 Cassandra 的 user_room 表（反向查詢表）
+// Primary Key: (uid)
+// Clustering Key: room_id
+// 設計說明：
+// - uid 作為 partition key，可以高效地查詢某個用戶所在的所有聊天室
+// - room_id 作為 clustering key，可以高效地查詢/刪除特定關聯
+// - 這個表用於支援「查詢用戶在哪些聊天室中」的需求
+type UserRoom struct {
+	UID      string     `db:"uid" partition_key:"true"`
+	RoomID   gocql.UUID `db:"room_id" clustering_key:"true"`
+	JoinedAt int64      `db:"joined_at"` // 加入時間
+}
+
+// TableName 返回表名
+func (u UserRoom) TableName() string {
+	return "user_room"
+}

pkg/chat/domain/repository/message.go

@@ -0,0 +1,41 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/entity"
+	"context"
+)
+
+// MessageRepository 定義訊息相關的資料存取介面
+type MessageRepository interface {
+	// Insert 插入訊息
+	Insert(ctx context.Context, msg *entity.Message) error
+	// ListMessages 查詢訊息列表（分頁）
+	ListMessages(ctx context.Context, param ListMessagesReq) ([]entity.Message, error)
+	// Count 計算符合條件的訊息總數
+	Count(ctx context.Context, RoomID string) (int64, error)
+	// CheckAndInsertDedup 檢查並插入去重記錄，如果已存在則返回 true（表示重複）
+	CheckAndInsertDedup(ctx context.Context, param CheckDupReq) (bool, error)
+}
+
+type SendMessageReq struct {
+	RoomID      string
+	UID         string
+	Content     string
+	ClientMsgID string
+}
+
+type ListMessagesReq struct {
+	RoomID    string
+	BucketDay string
+	PageSize  int
+	// LastTS 用於 cursor-based pagination，獲取 ts < LastTS 的訊息
+	// 如果為 0，則獲取最新的訊息
+	LastTS int64
+}
+
+type CheckDupReq struct {
+	RoomID     string
+	UID        string
+	BucketSec  int64
+	ContentMD5 string
+}

pkg/chat/domain/repository/room.go

@@ -0,0 +1,51 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/entity"
+	"context"
+)
+
+type RoomRepository interface {
+	Room
+	Member
+	User
+}
+
+// ListRoomsReq 查詢聊天室列表的請求參數
+type ListRoomsReq struct {
+	Status   string // 聊天室狀態（active, archived 等）
+	PageSize int    // 每頁大小
+	LastID   string // 用於 cursor-based pagination
+}
+
+// CountRoomsReq 統計聊天室的請求參數
+type CountRoomsReq struct {
+	Status string // 可選的狀態篩選
+}
+
+type Room interface {
+	Create(ctx context.Context, room *entity.Room) error                      // Create 創建聊天室
+	RoomGet(ctx context.Context, roomID string) (*entity.Room, error)         // Get 獲取聊天室資訊
+	RoomUpdate(ctx context.Context, room *entity.Room) error                  // Update 更新聊天室資訊
+	RoomDelete(ctx context.Context, roomID string) error                      // Delete 刪除聊天室（同時需要刪除相關的成員和訊息）
+	RoomList(ctx context.Context, param ListRoomsReq) ([]entity.Room, error)  // List 查詢聊天室列表（支援分頁和篩選）
+	RoomCount(ctx context.Context, param CountRoomsReq) (int64, error)        // Count 統計聊天室總數
+	RoomExists(ctx context.Context, roomID string) (bool, error)              // Exists 檢查聊天室是否存在
+	RoomGetByID(ctx context.Context, roomIDs []string) ([]entity.Room, error) // 取得 Room by id
+}
+
+type Member interface {
+	Insert(ctx context.Context, member *entity.RoomMember) error                // Insert 添加成員到聊天室
+	Get(ctx context.Context, roomID, uid string) (*entity.RoomMember, error)    // Get 獲取特定成員資訊
+	AllMembers(ctx context.Context, roomID string) ([]entity.RoomMember, error) // AllMembers 查詢聊天室所有成員
+	UpdateRole(ctx context.Context, member *entity.RoomMember) error            // UpdateRole 更新成員資訊（例如更新角色）
+	DeleteMember(ctx context.Context, roomID, uid string) error                 // DeleteMember 刪除特定成員（某人退出聊天室）
+	DeleteRoom(ctx context.Context, roomID string) error                        // DeleteRoom 刪除整個聊天室的所有成員
+	Count(ctx context.Context, roomID string) (int64, error)                    // Count 計算聊天室成員數量
+}
+
+type User interface {
+	GetUserRooms(ctx context.Context, uid string) ([]entity.UserRoom, error) // GetUserRooms 查詢用戶所在的所有聊天室
+	CountUserRooms(ctx context.Context, uid string) (int64, error)           // CountUserRooms 統計用戶所在的聊天室數量
+	IsUserInRoom(ctx context.Context, uid, roomID string) (bool, error)      // IsUserInRoom 檢查用戶是否在某個聊天室中
+}

pkg/chat/domain/usecase/message.go

@@ -0,0 +1,35 @@
+package usecase
+
+import (
+	"context"
+)
+
+// MessageUseCase 定義訊息相關的業務邏輯介面
+type MessageUseCase interface {
+	// SendMessage 發送訊息
+	SendMessage(ctx context.Context, param SendMessageReq) error
+	// ListMessages 查詢訊息列表（分頁）
+	ListMessages(ctx context.Context, req ListMessagesReq) ([]Message, int64, error)
+}
+
+type SendMessageReq struct {
+	RoomID  string
+	UID     string
+	Content string
+}
+
+type ListMessagesReq struct {
+	RoomID    string
+	UID       string
+	BucketDay string
+	PageSize  int64
+	LastTS    int64
+}
+
+type Message struct {
+	RoomID    string `json:"room_id"`
+	BucketDay string `json:"bucket_day"` // yyyyMMdd
+	TS        int64  `json:"ts"`         // timestamp
+	UID       string `json:"uid"`
+	Content   string `json:"content"`
+}

pkg/chat/repository/message.go

@@ -0,0 +1,165 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/entity"
+	"backend/pkg/chat/domain/repository"
+	"backend/pkg/library/cassandra"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/gocql/gocql"
+)
+
+type messageRepository struct {
+	repo      cassandra.Repository[entity.Message]
+	dedupRepo cassandra.Repository[entity.MessageDedup]
+	db        *cassandra.DB
+	keyspace  string
+}
+
+// MessageRepositoryParam 創建 MessageRepository 所需的參數
+type MessageRepositoryParam struct {
+	DB      *cassandra.DB
+	Keyspace string
+}
+
+// MustMessageRepository 創建 MessageRepository（如果失敗會 panic）
+func MustMessageRepository(param MessageRepositoryParam) repository.MessageRepository {
+	repo, err := NewMessageRepository(param.DB, param.Keyspace)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create message repository: %v", err))
+	}
+	return repo
+}
+
+// NewMessageRepository 創建新的訊息 Repository
+func NewMessageRepository(db *cassandra.DB, keyspace string) (repository.MessageRepository, error) {
+	repo, err := cassandra.NewRepository[entity.Message](db, keyspace)
+	if err != nil {
+		return nil, err
+	}
+
+	dedupRepo, err := cassandra.NewRepository[entity.MessageDedup](db, keyspace)
+	if err != nil {
+		return nil, err
+	}
+
+	return &messageRepository{
+		repo:      repo,
+		dedupRepo: dedupRepo,
+		db:        db,
+		keyspace:  keyspace,
+	}, nil
+}
+
+func (message *messageRepository) Insert(ctx context.Context, msg *entity.Message) error {
+	now := time.Now().UTC()
+	if msg.TS == 0 {
+		msg.TS = now.UnixNano()
+	}
+	// 只在 BucketDay 為空時才自動設置，保留先前傳入的值
+	if msg.BucketDay == "" {
+		msg.BucketDay = now.Format(time.DateOnly)
+	}
+
+	return message.repo.Insert(ctx, *msg)
+}
+
+func (message *messageRepository) ListMessages(ctx context.Context, param repository.ListMessagesReq) ([]entity.Message, error) {
+	// 設定預設分頁大小
+	if param.PageSize <= 0 {
+		param.PageSize = 20
+	}
+
+	// 將字串 RoomID 轉換為 UUID
+	roomUUID, err := gocql.ParseUUID(param.RoomID)
+	if err != nil {
+		return nil, err
+	}
+
+	// 構建查詢條件
+	query := message.repo.Query().
+		Where(cassandra.Eq("room_id", roomUUID)).
+		Where(cassandra.Eq("bucket_day", param.BucketDay))
+
+	// 使用 cursor-based pagination：如果提供了 LastTS，則查詢 ts < LastTS 的訊息
+	// 因為排序是 DESC，所以使用 < 來獲取更早的訊息（下一頁）
+	if param.LastTS > 0 {
+		query = query.Where(cassandra.Lt("ts", param.LastTS))
+	}
+
+	// 添加排序和限制
+	query = query.
+		OrderBy("ts", cassandra.DESC).
+		Limit(int(param.PageSize))
+
+	// 執行查詢
+	var messages []entity.Message
+	if err := query.Scan(ctx, &messages); err != nil {
+		return nil, err
+	}
+
+	return messages, nil
+}
+
+func (message *messageRepository) Count(ctx context.Context, roomID string) (int64, error) {
+	// 將字串 RoomID 轉換為 UUID
+	roomUUID, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return 0, err
+	}
+
+	// 注意：由於 partition key 是 (room_id, bucket_day)，只用 room_id 查詢需要 ALLOW FILTERING
+	// 這在生產環境中效能較差，建議改用按 bucket_day 分別查詢後加總
+	count, err := message.repo.Query().
+		Where(cassandra.Eq("room_id", roomUUID)).
+		AllowFiltering().
+		Count(ctx)
+	if err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+// CheckAndInsertDedup 檢查並插入去重記錄
+// 使用 IF NOT EXISTS 來實現原子性的去重檢查
+// 返回值：true 表示已存在（重複），false 表示成功插入（不重複）
+func (message *messageRepository) CheckAndInsertDedup(ctx context.Context, param repository.CheckDupReq) (bool, error) {
+	// 將字串 RoomID 轉換為 UUID
+	roomUUID, err := gocql.ParseUUID(param.RoomID)
+	if err != nil {
+		return false, err
+	}
+
+	// 使用 IF NOT EXISTS 來實現原子性的去重檢查
+	// 如果記錄已存在，INSERT 不會插入，且 applied = false
+	dedup := entity.MessageDedup{
+		RoomID:     roomUUID,
+		UID:        param.UID,
+		BucketSec:  param.BucketSec,
+		ContentMD5: param.ContentMD5,
+	}
+
+	// 使用原生 CQL 語句來實現 IF NOT EXISTS
+	tableName := dedup.TableName()
+	stmt := fmt.Sprintf(
+		"INSERT INTO %s.%s (room_id, uid, bucket_sec, content_md5) VALUES (?, ?, ?, ?) IF NOT EXISTS",
+		message.keyspace,
+		tableName,
+	)
+
+	// 執行 INSERT IF NOT EXISTS
+	applied, err := message.db.GetSession().Query(stmt, nil).
+		Bind(roomUUID, param.UID, param.BucketSec, param.ContentMD5).
+		WithContext(ctx).
+		MapScanCAS(make(map[string]interface{}))
+
+	if err != nil {
+		return false, fmt.Errorf("failed to check dedup: %w", err)
+	}
+
+	// applied = false 表示記錄已存在（重複）
+	// applied = true 表示成功插入（不重複）
+	return !applied, nil
+}

pkg/chat/repository/message_test.go

@@ -0,0 +1,526 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/entity"
+	"backend/pkg/chat/domain/repository"
+	"backend/pkg/library/cassandra"
+	"context"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/gocql/gocql"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/testcontainers/testcontainers-go"
+	"github.com/testcontainers/testcontainers-go/wait"
+)
+
+var (
+	// 全局變量：所有測試共享的資源
+	testDB           *cassandra.DB
+	testRepo         repository.MessageRepository
+	testContainer    testcontainers.Container
+	cleanupContainer func()
+)
+
+// TestMain 在所有測試之前執行一次，設置共享的資料庫
+func TestMain(m *testing.M) {
+	// 使用更長的 context 超時時間（Cassandra 啟動需要較長時間）
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+
+	// 啟動 Cassandra 容器（只執行一次）
+	// 不指定固定 port，讓 testcontainers 自動分配，避免與本地開發環境衝突
+	req := testcontainers.ContainerRequest{
+		Image:        "cassandra:4.1",
+		ExposedPorts: []string{"9042/tcp"},
+		// 等待 Cassandra 日誌確認啟動完成（Cassandra 啟動需要較長時間）
+		WaitingFor: wait.ForLog("Startup complete").
+			WithStartupTimeout(3 * time.Minute).
+			WithOccurrence(1),
+		Env: map[string]string{
+			"CASSANDRA_CLUSTER_NAME": "test-cluster",
+			"HEAP_NEWSIZE":           "128M",
+			"MAX_HEAP_SIZE":          "512M",
+		},
+	}
+
+	var err error
+	testContainer, err = testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
+		ContainerRequest: req,
+		Started:          true,
+	})
+	if err != nil {
+		panic("Failed to start Cassandra container: " + err.Error())
+	}
+
+	port, err := testContainer.MappedPort(ctx, "9042")
+	if err != nil {
+		testContainer.Terminate(ctx)
+		panic("Failed to get mapped port: " + err.Error())
+	}
+
+	host, err := testContainer.Host(ctx)
+	if err != nil {
+		testContainer.Terminate(ctx)
+		panic("Failed to get host: " + err.Error())
+	}
+
+	portInt, err := strconv.Atoi(port.Port())
+	if err != nil {
+		testContainer.Terminate(ctx)
+		panic("Failed to convert port to int: " + err.Error())
+	}
+
+	// 先創建 DB 連接（不指定 keyspace，因為 keyspace 還不存在）
+	testDB, err = cassandra.New(
+		cassandra.WithHosts(host),
+		cassandra.WithPort(portInt),
+		// 不指定 keyspace，先連接後再創建
+	)
+	if err != nil {
+		testContainer.Terminate(ctx)
+		panic("Failed to create DB: " + err.Error())
+	}
+
+	// 創建 keyspace（需要在連接後才能創建）
+	createKeyspaceStmt := "CREATE KEYSPACE IF NOT EXISTS test_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}"
+	if err := testDB.GetSession().Query(createKeyspaceStmt, nil).Exec(); err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create keyspace: " + err.Error())
+	}
+
+	// 等待 keyspace 創建完成
+	time.Sleep(500 * time.Millisecond)
+
+	// 創建 messages_by_room 表（需要指定 keyspace）
+	createTableStmt := `CREATE TABLE IF NOT EXISTS test_keyspace.messages_by_room (
+		room_id uuid,
+		bucket_day text,
+		ts bigint,
+		uid text,
+		content text,
+		PRIMARY KEY ((room_id, bucket_day), ts)
+	) WITH CLUSTERING ORDER BY (ts DESC)`
+	if err := testDB.GetSession().Query(createTableStmt, nil).Exec(); err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create table: " + err.Error())
+	}
+
+	// 創建 messages repository
+	testRepo, err = NewMessageRepository(testDB, "test_keyspace")
+	if err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create message repository: " + err.Error())
+	}
+
+	// 創建 room 相關表（供 room_test.go 使用）
+	createRoomTableStmt := `CREATE TABLE IF NOT EXISTS test_keyspace.room (
+		room_id uuid PRIMARY KEY,
+		name text,
+		status text,
+		created_at bigint,
+		updated_at bigint
+	)`
+	if err := testDB.GetSession().Query(createRoomTableStmt, nil).Exec(); err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create room table: " + err.Error())
+	}
+
+	createMemberTableStmt := `CREATE TABLE IF NOT EXISTS test_keyspace.room_member (
+		room_id uuid,
+		uid text,
+		role text,
+		joined_at bigint,
+		PRIMARY KEY (room_id, uid)
+	)`
+	if err := testDB.GetSession().Query(createMemberTableStmt, nil).Exec(); err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create room_member table: " + err.Error())
+	}
+
+	createUserRoomTableStmt := `CREATE TABLE IF NOT EXISTS test_keyspace.user_room (
+		uid text,
+		room_id uuid,
+		joined_at bigint,
+		PRIMARY KEY (uid, room_id)
+	)`
+	if err := testDB.GetSession().Query(createUserRoomTableStmt, nil).Exec(); err != nil {
+		testDB.Close()
+		testContainer.Terminate(ctx)
+		panic("Failed to create user_room table: " + err.Error())
+	}
+
+	// 設置清理函數
+	cleanupContainer = func() {
+		if testDB != nil {
+			testDB.Close()
+		}
+		if testContainer != nil {
+			_ = testContainer.Terminate(ctx)
+		}
+	}
+
+	// 執行所有測試
+	code := m.Run()
+
+	// 清理資源
+	cleanupContainer()
+
+	// 退出
+	os.Exit(code)
+}
+
+// clearMessages 清空 messages_by_room 表的所有數據
+func clearMessages(t *testing.T) {
+	ctx := context.Background()
+	// 使用完整的 keyspace.table 名稱
+	truncateStmt := "TRUNCATE test_keyspace.messages_by_room"
+	if err := testDB.GetSession().Query(truncateStmt, nil).WithContext(ctx).Exec(); err != nil {
+		t.Fatalf("Failed to truncate messages_by_room table: %v", err)
+	}
+	// 等待數據清空
+	time.Sleep(50 * time.Millisecond)
+}
+
+func TestNewMessageRepository(t *testing.T) {
+	clearMessages(t)
+	assert.NotNil(t, testRepo)
+}
+
+func TestMessageRepository_Insert(t *testing.T) {
+	clearMessages(t)
+	ctx := context.Background()
+
+	tests := []struct {
+		name    string
+		message *entity.Message
+		wantErr bool
+	}{
+		{
+			name: "successful insert",
+			message: &entity.Message{
+				RoomID:    gocql.TimeUUID(),
+				BucketDay: "20250117",
+				TS:        time.Now().UnixNano(),
+				UID:       "user-1",
+				Content:   "Hello, world!",
+			},
+			wantErr: false,
+		},
+		{
+			name: "insert with auto timestamp",
+			message: &entity.Message{
+				RoomID:    gocql.TimeUUID(),
+				BucketDay: "20250117",
+				UID:       "user-2",
+				Content:   "Test message",
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := testRepo.Insert(ctx, tt.message)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				// 驗證 TS 和 BucketDay 是否被自動設置
+				if tt.message.TS == 0 {
+					assert.NotZero(t, tt.message.TS)
+				}
+				if tt.message.BucketDay == "" {
+					assert.NotEmpty(t, tt.message.BucketDay)
+				}
+			}
+		})
+	}
+}
+
+func TestMessageRepository_ListMessages(t *testing.T) {
+	clearMessages(t)
+	ctx := context.Background()
+	roomID := gocql.TimeUUID()
+	roomIDStr := roomID.String()
+	bucketDay := time.Now().Format(time.DateOnly)
+
+	// 插入測試數據（使用相同的 roomID）
+	messages := []*entity.Message{
+		{RoomID: roomID, BucketDay: bucketDay, TS: time.Now().UnixNano(), UID: "user-1", Content: "Message 1"},
+		{RoomID: roomID, BucketDay: bucketDay, TS: time.Now().Add(time.Second).UnixNano(), UID: "user-2", Content: "Message 2"},
+		{RoomID: roomID, BucketDay: bucketDay, TS: time.Now().Add(2 * time.Second).UnixNano(), UID: "user-3", Content: "Message 3"},
+	}
+
+	for _, msg := range messages {
+		require.NoError(t, testRepo.Insert(ctx, msg))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		param   repository.ListMessagesReq
+		wantLen int
+		wantErr bool
+	}{
+		{
+			name: "list all messages",
+			param: repository.ListMessagesReq{
+				RoomID:    roomIDStr,
+				BucketDay: bucketDay,
+				PageSize:  10,
+				LastTS:    0,
+			},
+			wantLen: 3,
+			wantErr: false,
+		},
+		{
+			name: "list with page size limit",
+			param: repository.ListMessagesReq{
+				RoomID:    roomIDStr,
+				BucketDay: bucketDay,
+				PageSize:  2,
+				LastTS:    0,
+			},
+			wantLen: 2,
+			wantErr: false,
+		},
+		{
+			name: "list with cursor pagination",
+			param: repository.ListMessagesReq{
+				RoomID:    roomIDStr,
+				BucketDay: bucketDay,
+				PageSize:  10,
+				LastTS:    messages[1].TS, // 使用第二條訊息的 TS 作為 cursor
+			},
+			wantLen: 1, // 應該只返回比 LastTS 更早的訊息
+			wantErr: false,
+		},
+		{
+			name: "list with default page size",
+			param: repository.ListMessagesReq{
+				RoomID:    roomIDStr,
+				BucketDay: bucketDay,
+				PageSize:  0, // 應該使用預設值 20
+				LastTS:    0,
+			},
+			wantLen: 3,
+			wantErr: false,
+		},
+		{
+			name: "list empty room",
+			param: repository.ListMessagesReq{
+				RoomID:    gocql.TimeUUID().String(), // 使用不存在的 UUID
+				BucketDay: bucketDay,
+				PageSize:  10,
+				LastTS:    0,
+			},
+			wantLen: 0,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := testRepo.ListMessages(ctx, tt.param)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Len(t, result, tt.wantLen)
+				// 驗證排序（應該按 TS DESC 排序）
+				if len(result) > 1 {
+					for i := 0; i < len(result)-1; i++ {
+						assert.GreaterOrEqual(t, result[i].TS, result[i+1].TS, "Messages should be sorted by TS DESC")
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestMessageRepository_Count(t *testing.T) {
+	clearMessages(t)
+	ctx := context.Background()
+	roomID := gocql.TimeUUID()
+	roomIDStr := roomID.String()
+	bucketDay := time.Now().Format(time.DateOnly)
+
+	// 插入測試數據（使用相同的 roomID）
+	for i := 0; i < 5; i++ {
+		msg := &entity.Message{
+			RoomID:    roomID,
+			BucketDay: bucketDay,
+			TS:        time.Now().Add(time.Duration(i) * time.Second).UnixNano(),
+			UID:       "user-1",
+			Content:   "Message",
+		}
+		require.NoError(t, testRepo.Insert(ctx, msg))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		roomID  string
+		want    int64
+		wantErr bool
+	}{
+		{
+			name:    "count existing room",
+			roomID:  roomIDStr,
+			want:    5,
+			wantErr: false,
+		},
+		{
+			name:    "count non-existent room",
+			roomID:  gocql.TimeUUID().String(), // 使用不存在的 UUID
+			want:    0,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			count, err := testRepo.Count(ctx, tt.roomID)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.want, count)
+			}
+		})
+	}
+}
+
+func TestMessageRepository_Insert_ListMessages_Integration(t *testing.T) {
+	clearMessages(t)
+	ctx := context.Background()
+	roomID := gocql.TimeUUID()
+	roomIDStr := roomID.String()
+	bucketDay := time.Now().Format(time.DateOnly)
+
+	// 插入多條訊息（使用相同的 roomID）
+	messages := make([]*entity.Message, 10)
+	for i := 0; i < 10; i++ {
+		msg := &entity.Message{
+			RoomID:    roomID,
+			BucketDay: bucketDay,
+			TS:        time.Now().Add(time.Duration(i) * time.Second).UnixNano(),
+			UID:       "user-1",
+			Content:   "Message",
+		}
+		messages[i] = msg
+		require.NoError(t, testRepo.Insert(ctx, msg))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 驗證可以查詢到所有訊息
+	result, err := testRepo.ListMessages(ctx, repository.ListMessagesReq{
+		RoomID:    roomIDStr,
+		BucketDay: bucketDay,
+		PageSize:  20,
+		LastTS:    0,
+	})
+	require.NoError(t, err)
+	assert.Len(t, result, 10)
+
+	// 驗證分頁功能
+	firstPage, err := testRepo.ListMessages(ctx, repository.ListMessagesReq{
+		RoomID:    roomIDStr,
+		BucketDay: bucketDay,
+		PageSize:  5,
+		LastTS:    0,
+	})
+	require.NoError(t, err)
+	assert.Len(t, firstPage, 5)
+
+	// 使用 cursor 獲取下一頁
+	if len(firstPage) > 0 {
+		lastTS := firstPage[len(firstPage)-1].TS
+		secondPage, err := testRepo.ListMessages(ctx, repository.ListMessagesReq{
+			RoomID:    roomIDStr,
+			BucketDay: bucketDay,
+			PageSize:  5,
+			LastTS:    lastTS,
+		})
+		require.NoError(t, err)
+		assert.Len(t, secondPage, 5)
+		// 驗證第二頁的訊息都比第一頁的最後一條更早
+		if len(secondPage) > 0 {
+			assert.Less(t, secondPage[0].TS, lastTS)
+		}
+	}
+
+	// 驗證計數
+	count, err := testRepo.Count(ctx, roomIDStr)
+	require.NoError(t, err)
+	assert.Equal(t, int64(10), count)
+}
+
+func TestMessageRepository_DifferentBuckets(t *testing.T) {
+	clearMessages(t)
+	ctx := context.Background()
+	roomID := gocql.TimeUUID()
+	roomIDStr := roomID.String()
+	today := time.Now().Format(time.DateOnly)
+	yesterday := time.Now().AddDate(0, 0, -1).Format(time.DateOnly)
+
+	// 插入不同 bucket 的訊息（使用相同的 roomID）
+	todayMsg := &entity.Message{
+		RoomID:    roomID,
+		BucketDay: today,
+		TS:        time.Now().UnixNano(),
+		UID:       "user-1",
+		Content:   "Today's message",
+	}
+	yesterdayMsg := &entity.Message{
+		RoomID:    roomID,
+		BucketDay: yesterday,
+		TS:        time.Now().UnixNano(),
+		UID:       "user-1",
+		Content:   "Yesterday's message",
+	}
+
+	require.NoError(t, testRepo.Insert(ctx, todayMsg))
+	require.NoError(t, testRepo.Insert(ctx, yesterdayMsg))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 查詢今天的訊息
+	todayMessages, err := testRepo.ListMessages(ctx, repository.ListMessagesReq{
+		RoomID:    roomIDStr,
+		BucketDay: today,
+		PageSize:  10,
+		LastTS:    0,
+	})
+	require.NoError(t, err)
+	assert.Len(t, todayMessages, 1)
+	assert.Equal(t, "Today's message", todayMessages[0].Content)
+
+	// 查詢昨天的訊息
+	yesterdayMessages, err := testRepo.ListMessages(ctx, repository.ListMessagesReq{
+		RoomID:    roomIDStr,
+		BucketDay: yesterday,
+		PageSize:  10,
+		LastTS:    0,
+	})
+	require.NoError(t, err)
+	assert.Len(t, yesterdayMessages, 1)
+	assert.Equal(t, "Yesterday's message", yesterdayMessages[0].Content)
+}

pkg/chat/repository/room.go

@@ -0,0 +1,404 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/chat"
+	"backend/pkg/chat/domain/entity"
+	"backend/pkg/chat/domain/repository"
+	"backend/pkg/library/cassandra"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/gocql/gocql"
+)
+
+type roomRepository struct {
+	roomRepo     cassandra.Repository[entity.Room]
+	memberRepo   cassandra.Repository[entity.RoomMember]
+	userRoomRepo cassandra.Repository[entity.UserRoom]
+	db           *cassandra.DB
+	keyspace     string
+}
+
+// RoomRepositoryParam 創建 RoomRepository 所需的參數
+type RoomRepositoryParam struct {
+	DB      *cassandra.DB
+	Keyspace string
+}
+
+// MustRoomRepository 創建 RoomRepository（如果失敗會 panic）
+func MustRoomRepository(param RoomRepositoryParam) repository.RoomRepository {
+	repo, err := NewRoomRepository(param.DB, param.Keyspace)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create room repository: %v", err))
+	}
+	return repo
+}
+
+// NewRoomRepository 創建新的聊天室 Repository
+func NewRoomRepository(db *cassandra.DB, keyspace string) (repository.RoomRepository, error) {
+	roomRepo, err := cassandra.NewRepository[entity.Room](db, keyspace)
+	if err != nil {
+		return nil, err
+	}
+
+	memberRepo, err := cassandra.NewRepository[entity.RoomMember](db, keyspace)
+	if err != nil {
+		return nil, err
+	}
+
+	userRoomRepo, err := cassandra.NewRepository[entity.UserRoom](db, keyspace)
+	if err != nil {
+		return nil, err
+	}
+
+	return &roomRepository{
+		roomRepo:     roomRepo,
+		memberRepo:   memberRepo,
+		userRoomRepo: userRoomRepo,
+		db:           db,
+		keyspace:     keyspace,
+	}, nil
+}
+
+// ==================== Room Interface 實作 ====================
+
+func (r *roomRepository) Create(ctx context.Context, room *entity.Room) error {
+	now := time.Now().UTC().UnixNano()
+	if room.CreatedAt == 0 {
+		room.CreatedAt = now
+	}
+	if room.UpdatedAt == 0 {
+		room.UpdatedAt = now
+	}
+	room.RoomID = gocql.TimeUUID()
+
+	return r.roomRepo.Insert(ctx, *room)
+}
+
+func (r *roomRepository) RoomGet(ctx context.Context, roomID string) (*entity.Room, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return nil, err
+	}
+	room, err := r.roomRepo.Get(ctx, entity.Room{
+		RoomID: uuid,
+	})
+	if err != nil {
+		if cassandra.IsNotFound(err) {
+			return nil, cassandra.ErrNotFound
+		}
+
+		return nil, err
+	}
+
+	return &room, nil
+}
+
+func (r *roomRepository) RoomUpdate(ctx context.Context, room *entity.Room) error {
+	update := entity.Room{}
+	now := time.Now().UTC().UnixNano()
+
+	get, err := r.RoomGet(ctx, room.RoomID.String())
+	if err != nil {
+		return err
+	}
+
+	update.CreatedAt = get.CreatedAt
+	update.UpdatedAt = now
+	update.Status = room.Status
+	update.Name = room.Name
+	update.RoomID = room.RoomID
+
+	if err = r.roomRepo.Update(ctx, update); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *roomRepository) RoomDelete(ctx context.Context, roomID string) error {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return err
+	}
+
+	// 使用原生 CQL 語句來刪除，避免 cassandra library Delete 方法的 struct 綁定問題
+	e := entity.Room{}
+	stmt := fmt.Sprintf("DELETE FROM %s.%s WHERE room_id = ?", r.keyspace, e.TableName())
+	return r.db.GetSession().Query(stmt, nil).
+		Bind(uuid).
+		WithContext(ctx).
+		ExecRelease()
+}
+
+func (r *roomRepository) RoomList(ctx context.Context, param repository.ListRoomsReq) ([]entity.Room, error) {
+	query := r.roomRepo.Query()
+
+	if param.Status != "" {
+		query = query.Where(cassandra.Eq("status", param.Status)).AllowFiltering()
+	}
+
+	if param.PageSize > 0 {
+		query = query.Limit(param.PageSize)
+	}
+
+	if param.LastID != "" {
+		lastUUID, err := gocql.ParseUUID(param.LastID)
+		if err != nil {
+			return nil, err
+		}
+		query = query.Where(cassandra.Lt("room_id", lastUUID))
+	}
+
+	var rooms []entity.Room
+	if err := query.Scan(ctx, &rooms); err != nil {
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+func (r *roomRepository) RoomCount(ctx context.Context, param repository.CountRoomsReq) (int64, error) {
+	query := r.roomRepo.Query()
+	if param.Status != "" {
+		query = query.Where(cassandra.Eq("status", param.Status)).AllowFiltering()
+	}
+	return query.Count(ctx)
+}
+
+func (r *roomRepository) RoomExists(ctx context.Context, roomID string) (bool, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return false, err
+	}
+	_, err = r.roomRepo.Get(ctx, entity.Room{
+		RoomID: uuid,
+	})
+
+	if err != nil {
+		if cassandra.IsNotFound(err) {
+			return false, nil
+		}
+
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (r *roomRepository) RoomGetByID(ctx context.Context, roomIDs []string) ([]entity.Room, error) {
+	if len(roomIDs) == 0 {
+		return []entity.Room{}, nil
+	}
+
+	// 將字串 ID 轉換為 UUID
+	uuids := make([]any, 0, len(roomIDs))
+	for _, id := range roomIDs {
+		uuid, err := gocql.ParseUUID(id)
+		if err != nil {
+			return nil, err
+		}
+		uuids = append(uuids, uuid)
+	}
+
+	var rooms []entity.Room
+	err := r.roomRepo.Query().
+		Where(cassandra.In("room_id", uuids)).
+		Scan(ctx, &rooms)
+	if err != nil {
+		return nil, err
+	}
+
+	return rooms, nil
+}
+
+// ==================== Member Interface 實作 ====================
+
+func (r *roomRepository) Insert(ctx context.Context, member *entity.RoomMember) error {
+	now := time.Now().UTC().UnixNano()
+	if member.JoinedAt == 0 {
+		member.JoinedAt = now
+	}
+	if member.Role == "" {
+		member.Role = chat.RoomRoleMember.String()
+	}
+
+	// 同時插入到 user_room 表（反向查詢表）
+	userRoom := entity.UserRoom{
+		UID:      member.UID,
+		RoomID:   member.RoomID,
+		JoinedAt: member.JoinedAt,
+	}
+
+	if err := r.memberRepo.Insert(ctx, *member); err != nil {
+		return err
+	}
+
+	if err := r.userRoomRepo.Insert(ctx, userRoom); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *roomRepository) Get(ctx context.Context, roomID, uid string) (*entity.RoomMember, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return nil, err
+	}
+
+	member, err := r.memberRepo.Get(ctx, entity.RoomMember{
+		RoomID: uuid,
+		UID:    uid,
+	})
+	if err != nil {
+		if cassandra.IsNotFound(err) {
+			return nil, cassandra.ErrNotFound
+		}
+		return nil, err
+	}
+	return &member, nil
+}
+
+func (r *roomRepository) AllMembers(ctx context.Context, roomID string) ([]entity.RoomMember, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return nil, err
+	}
+
+	var members []entity.RoomMember
+	err = r.memberRepo.Query().
+		Where(cassandra.Eq("room_id", uuid)).
+		Scan(ctx, &members)
+	if err != nil {
+		return nil, err
+	}
+	return members, nil
+}
+
+func (r *roomRepository) UpdateRole(ctx context.Context, member *entity.RoomMember) error {
+	get, err := r.Get(ctx, member.RoomID.String(), member.UID)
+	if err != nil {
+		return err
+	}
+
+	update := entity.RoomMember{
+		RoomID:   member.RoomID,
+		UID:      member.UID,
+		Role:     member.Role,
+		JoinedAt: get.JoinedAt,
+	}
+
+	return r.memberRepo.Update(ctx, update)
+}
+
+func (r *roomRepository) DeleteMember(ctx context.Context, roomID, uid string) error {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return err
+	}
+
+	// 同時從兩個表中刪除
+	if err := r.memberRepo.Delete(ctx, entity.RoomMember{
+		RoomID: uuid,
+		UID:    uid,
+	}); err != nil {
+		return err
+	}
+
+	if err := r.userRoomRepo.Delete(ctx, entity.UserRoom{
+		UID:    uid,
+		RoomID: uuid,
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *roomRepository) DeleteRoom(ctx context.Context, roomID string) error {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return err
+	}
+
+	// 先查詢所有成員（必須在刪除之前查詢）
+	members, err := r.AllMembers(ctx, roomID)
+	if err != nil {
+		return err
+	}
+
+	// 刪除 user_room 表中的所有關聯
+	for _, member := range members {
+		if err := r.userRoomRepo.Delete(ctx, entity.UserRoom{
+			UID:    member.UID,
+			RoomID: uuid,
+		}); err != nil {
+			return err
+		}
+	}
+
+	// 最後刪除 room_member 表中的所有成員
+	e := entity.RoomMember{}
+	stmt := fmt.Sprintf("DELETE FROM %s.%s WHERE room_id = ?", r.keyspace, e.TableName())
+	if err := r.db.GetSession().Query(stmt, nil).
+		Bind(uuid).
+		WithContext(ctx).
+		WithTimestamp(time.Now().UnixNano() / 1e3).
+		ExecRelease(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *roomRepository) Count(ctx context.Context, roomID string) (int64, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return 0, err
+	}
+
+	return r.memberRepo.Query().
+		Where(cassandra.Eq("room_id", uuid)).
+		Count(ctx)
+}
+
+// ==================== User Interface 實作 ====================
+
+func (r *roomRepository) GetUserRooms(ctx context.Context, uid string) ([]entity.UserRoom, error) {
+	var userRooms []entity.UserRoom
+	err := r.userRoomRepo.Query().
+		Where(cassandra.Eq("uid", uid)).
+		Scan(ctx, &userRooms)
+	if err != nil {
+		return nil, err
+	}
+
+	return userRooms, nil
+}
+
+func (r *roomRepository) CountUserRooms(ctx context.Context, uid string) (int64, error) {
+	return r.userRoomRepo.Query().
+		Where(cassandra.Eq("uid", uid)).
+		Count(ctx)
+}
+
+func (r *roomRepository) IsUserInRoom(ctx context.Context, uid, roomID string) (bool, error) {
+	uuid, err := gocql.ParseUUID(roomID)
+	if err != nil {
+		return false, err
+	}
+
+	_, err = r.userRoomRepo.Get(ctx, entity.UserRoom{
+		UID:    uid,
+		RoomID: uuid,
+	})
+	if err != nil {
+		if cassandra.IsNotFound(err) {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}

pkg/chat/repository/room_test.go

@@ -0,0 +1,953 @@
+package repository
+
+import (
+	"backend/pkg/chat/domain/chat"
+	"backend/pkg/chat/domain/entity"
+	"backend/pkg/chat/domain/repository"
+	"backend/pkg/library/cassandra"
+	"context"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/gocql/gocql"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	// 全局變量：所有測試共享的資源（與 message_test.go 共享）
+	roomTestRepo repository.RoomRepository
+)
+
+// ensureRoomRepository 確保 Room Repository 已初始化
+func ensureRoomRepository(t *testing.T) {
+	if roomTestRepo == nil {
+		if testDB == nil {
+			t.Fatal("testDB is not initialized. Make sure TestMain in message_test.go runs first.")
+		}
+		var err error
+		roomTestRepo, err = NewRoomRepository(testDB, "test_keyspace")
+		if err != nil {
+			t.Fatalf("Failed to create room repository: %v", err)
+		}
+	}
+}
+
+// clearRoomData 清空所有 room 相關表的數據
+func clearRoomData(t *testing.T) {
+	ctx := context.Background()
+	tables := []string{"user_room", "room_member", "room"}
+	for _, table := range tables {
+		truncateStmt := "TRUNCATE test_keyspace." + table
+		if err := testDB.GetSession().Query(truncateStmt, nil).WithContext(ctx).Exec(); err != nil {
+			t.Fatalf("Failed to truncate %s table: %v", table, err)
+		}
+	}
+	// 等待數據清空
+	time.Sleep(50 * time.Millisecond)
+}
+
+// ==================== Room Interface 測試 ====================
+
+func TestNewRoomRepository(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	assert.NotNil(t, roomTestRepo)
+}
+
+func TestRoomRepository_Create(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	tests := []struct {
+		name    string
+		room    *entity.Room
+		wantErr bool
+	}{
+		{
+			name: "successful create",
+			room: &entity.Room{
+				Name:   "Test Room",
+				Status: "active",
+			},
+			wantErr: false,
+		},
+		{
+			name: "create with auto timestamp",
+			room: &entity.Room{
+				Name:   "Auto Timestamp Room",
+				Status: "active",
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := roomTestRepo.Create(ctx, tt.room)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				// 驗證 RoomID 和時間戳是否被自動設置
+				assert.NotZero(t, tt.room.RoomID)
+				assert.NotZero(t, tt.room.CreatedAt)
+				assert.NotZero(t, tt.room.UpdatedAt)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_RoomGet(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Get Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+	roomIDStr := room.RoomID.String()
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		roomID  string
+		wantErr bool
+	}{
+		{
+			name:    "get existing room",
+			roomID:  roomIDStr,
+			wantErr: false,
+		},
+		{
+			name:    "get non-existent room",
+			roomID:  gocql.TimeUUID().String(),
+			wantErr: true,
+		},
+		{
+			name:    "get with invalid UUID",
+			roomID:  "invalid-uuid",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := roomTestRepo.RoomGet(ctx, tt.roomID)
+			if tt.wantErr {
+				assert.Error(t, err)
+				assert.Nil(t, result)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, result)
+				assert.Equal(t, room.Name, result.Name)
+				assert.Equal(t, room.Status, result.Status)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_RoomUpdate(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Original Name",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+	originalCreatedAt := room.CreatedAt
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 更新房間
+	room.Name = "Updated Name"
+	room.Status = "archived"
+	err := roomTestRepo.RoomUpdate(ctx, room)
+	require.NoError(t, err)
+
+	// 驗證更新
+	updated, err := roomTestRepo.RoomGet(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Equal(t, "Updated Name", updated.Name)
+	assert.Equal(t, "archived", updated.Status)
+	assert.Equal(t, originalCreatedAt, updated.CreatedAt) // CreatedAt 不應該改變
+	assert.Greater(t, updated.UpdatedAt, originalCreatedAt) // UpdatedAt 應該更新
+}
+
+func TestRoomRepository_RoomDelete(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Delete Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+	roomIDStr := room.RoomID.String()
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 刪除房間
+	err := roomTestRepo.RoomDelete(ctx, roomIDStr)
+	require.NoError(t, err)
+
+	// 驗證房間已被刪除
+	_, err = roomTestRepo.RoomGet(ctx, roomIDStr)
+	assert.Error(t, err)
+	assert.True(t, cassandra.IsNotFound(err))
+}
+
+func TestRoomRepository_RoomList(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建多個測試房間
+	rooms := make([]*entity.Room, 5)
+	for i := 0; i < 5; i++ {
+		room := &entity.Room{
+			Name:   "Room " + strconv.Itoa(i),
+			Status: "active",
+		}
+		require.NoError(t, roomTestRepo.Create(ctx, room))
+		rooms[i] = room
+		time.Sleep(10 * time.Millisecond) // 確保時間戳不同
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		param   repository.ListRoomsReq
+		wantLen int
+		wantErr bool
+	}{
+		{
+			name: "list all rooms",
+			param: repository.ListRoomsReq{
+				PageSize: 10,
+			},
+			wantLen: 5,
+			wantErr: false,
+		},
+		{
+			name: "list with status filter",
+			param: repository.ListRoomsReq{
+				Status:   "active",
+				PageSize: 10,
+			},
+			wantLen: 5,
+			wantErr: false,
+		},
+		{
+			name: "list with page size limit",
+			param: repository.ListRoomsReq{
+				PageSize: 2,
+			},
+			wantLen: 2,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := roomTestRepo.RoomList(ctx, tt.param)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Len(t, result, tt.wantLen)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_RoomCount(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	for i := 0; i < 3; i++ {
+		room := &entity.Room{
+			Name:   "Count Room " + strconv.Itoa(i),
+			Status: "active",
+		}
+		require.NoError(t, roomTestRepo.Create(ctx, room))
+	}
+
+	// 創建一個 archived 房間
+	archivedRoom := &entity.Room{
+		Name:   "Archived Room",
+		Status: "archived",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, archivedRoom))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		param   repository.CountRoomsReq
+		want    int64
+		wantErr bool
+	}{
+		{
+			name: "count all rooms",
+			param: repository.CountRoomsReq{},
+			want:  4,
+		},
+		{
+			name: "count active rooms",
+			param: repository.CountRoomsReq{
+				Status: "active",
+			},
+			want: 3,
+		},
+		{
+			name: "count archived rooms",
+			param: repository.CountRoomsReq{
+				Status: "archived",
+			},
+			want: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			count, err := roomTestRepo.RoomCount(ctx, tt.param)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.want, count)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_RoomExists(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Exists Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+	roomIDStr := room.RoomID.String()
+	nonExistentID := gocql.TimeUUID().String()
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		roomID  string
+		want    bool
+		wantErr bool
+	}{
+		{
+			name:    "existing room",
+			roomID:  roomIDStr,
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name:    "non-existent room",
+			roomID:  nonExistentID,
+			want:    false,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			exists, err := roomTestRepo.RoomExists(ctx, tt.roomID)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.want, exists)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_RoomGetByID(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建多個測試房間
+	rooms := make([]*entity.Room, 3)
+	roomIDs := make([]string, 3)
+	for i := 0; i < 3; i++ {
+		room := &entity.Room{
+			Name:   "Room " + strconv.Itoa(i),
+			Status: "active",
+		}
+		require.NoError(t, roomTestRepo.Create(ctx, room))
+		rooms[i] = room
+		roomIDs[i] = room.RoomID.String()
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		roomIDs []string
+		wantLen int
+		wantErr bool
+	}{
+		{
+			name:    "get multiple rooms",
+			roomIDs: roomIDs,
+			wantLen: 3,
+			wantErr: false,
+		},
+		{
+			name:    "get empty list",
+			roomIDs: []string{},
+			wantLen: 0,
+			wantErr: false,
+		},
+		{
+			name:    "get with non-existent ID",
+			roomIDs: []string{roomIDs[0], gocql.TimeUUID().String()},
+			wantLen: 1, // 只返回存在的房間
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := roomTestRepo.RoomGetByID(ctx, tt.roomIDs)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Len(t, result, tt.wantLen)
+			}
+		})
+	}
+}
+
+// ==================== Member Interface 測試 ====================
+
+func TestRoomRepository_Insert(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Member Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	tests := []struct {
+		name    string
+		member  *entity.RoomMember
+		wantErr bool
+	}{
+		{
+			name: "successful insert",
+			member: &entity.RoomMember{
+				RoomID: room.RoomID,
+				UID:    "user-1",
+				Role:   chat.RoomRoleMember.String(),
+			},
+			wantErr: false,
+		},
+		{
+			name: "insert with auto role",
+			member: &entity.RoomMember{
+				RoomID: room.RoomID,
+				UID:    "user-2",
+			},
+			wantErr: false,
+		},
+		{
+			name: "insert with admin role",
+			member: &entity.RoomMember{
+				RoomID: room.RoomID,
+				UID:    "user-3",
+				Role:   chat.RoomRoleAdmin.String(),
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := roomTestRepo.Insert(ctx, tt.member)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				// 驗證 JoinedAt 是否被自動設置
+				assert.NotZero(t, tt.member.JoinedAt)
+				// 驗證 Role 是否被自動設置（如果為空）
+				if tt.member.Role == "" {
+					assert.Equal(t, chat.RoomRoleMember.String(), tt.member.Role)
+				}
+
+				// 驗證 user_room 表也被更新
+				userRooms, err := roomTestRepo.GetUserRooms(ctx, tt.member.UID)
+				require.NoError(t, err)
+				assert.Greater(t, len(userRooms), 0)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_Get(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間和成員
+	room := &entity.Room{
+		Name:   "Get Member Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	member := &entity.RoomMember{
+		RoomID: room.RoomID,
+		UID:    "user-1",
+		Role:   chat.RoomRoleAdmin.String(),
+	}
+	require.NoError(t, roomTestRepo.Insert(ctx, member))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		roomID  string
+		uid     string
+		wantErr bool
+	}{
+		{
+			name:    "get existing member",
+			roomID:  room.RoomID.String(),
+			uid:     "user-1",
+			wantErr: false,
+		},
+		{
+			name:    "get non-existent member",
+			roomID:  room.RoomID.String(),
+			uid:     "non-existent-user",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := roomTestRepo.Get(ctx, tt.roomID, tt.uid)
+			if tt.wantErr {
+				assert.Error(t, err)
+				assert.Nil(t, result)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, result)
+				assert.Equal(t, member.UID, result.UID)
+				assert.Equal(t, member.Role, result.Role)
+			}
+		})
+	}
+}
+
+func TestRoomRepository_AllMembers(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "All Members Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	// 插入多個成員
+	members := []*entity.RoomMember{
+		{RoomID: room.RoomID, UID: "user-1", Role: chat.RoomRoleMember.String()},
+		{RoomID: room.RoomID, UID: "user-2", Role: chat.RoomRoleAdmin.String()},
+		{RoomID: room.RoomID, UID: "user-3", Role: chat.RoomRoleMember.String()},
+	}
+
+	for _, member := range members {
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 查詢所有成員
+	result, err := roomTestRepo.AllMembers(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Len(t, result, 3)
+}
+
+func TestRoomRepository_UpdateRole(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間和成員
+	room := &entity.Room{
+		Name:   "Update Role Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	member := &entity.RoomMember{
+		RoomID: room.RoomID,
+		UID:    "user-1",
+		Role:   chat.RoomRoleMember.String(),
+	}
+	require.NoError(t, roomTestRepo.Insert(ctx, member))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 更新角色
+	member.Role = chat.RoomRoleAdmin.String()
+	err := roomTestRepo.UpdateRole(ctx, member)
+	require.NoError(t, err)
+
+	// 驗證更新
+	updated, err := roomTestRepo.Get(ctx, room.RoomID.String(), "user-1")
+	require.NoError(t, err)
+	assert.Equal(t, chat.RoomRoleAdmin.String(), updated.Role)
+}
+
+func TestRoomRepository_DeleteMember(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間和成員
+	room := &entity.Room{
+		Name:   "Delete Member Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	member := &entity.RoomMember{
+		RoomID: room.RoomID,
+		UID:    "user-1",
+		Role:   chat.RoomRoleMember.String(),
+	}
+	require.NoError(t, roomTestRepo.Insert(ctx, member))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 刪除成員
+	err := roomTestRepo.DeleteMember(ctx, room.RoomID.String(), "user-1")
+	require.NoError(t, err)
+
+	// 驗證成員已被刪除
+	_, err = roomTestRepo.Get(ctx, room.RoomID.String(), "user-1")
+	assert.Error(t, err)
+	assert.True(t, cassandra.IsNotFound(err))
+
+	// 驗證 user_room 表也被刪除
+	userRooms, err := roomTestRepo.GetUserRooms(ctx, "user-1")
+	require.NoError(t, err)
+	assert.Len(t, userRooms, 0)
+}
+
+func TestRoomRepository_DeleteRoom(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Delete Room Test",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	// 插入多個成員
+	members := []*entity.RoomMember{
+		{RoomID: room.RoomID, UID: "user-1", Role: chat.RoomRoleMember.String()},
+		{RoomID: room.RoomID, UID: "user-2", Role: chat.RoomRoleAdmin.String()},
+	}
+
+	for _, member := range members {
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 刪除整個房間
+	err := roomTestRepo.DeleteRoom(ctx, room.RoomID.String())
+	require.NoError(t, err)
+
+	// 驗證所有成員已被刪除
+	allMembers, err := roomTestRepo.AllMembers(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Len(t, allMembers, 0)
+
+	// 驗證 user_room 表中的關聯也被刪除
+	for _, member := range members {
+		userRooms, err := roomTestRepo.GetUserRooms(ctx, member.UID)
+		require.NoError(t, err)
+		// 驗證該用戶的 user_room 記錄中不包含這個房間
+		found := false
+		for _, ur := range userRooms {
+			if ur.RoomID == room.RoomID {
+				found = true
+				break
+			}
+		}
+		assert.False(t, found, "user_room should not contain deleted room")
+	}
+}
+
+func TestRoomRepository_Count(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Count Members Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	// 插入多個成員
+	for i := 0; i < 5; i++ {
+		member := &entity.RoomMember{
+			RoomID: room.RoomID,
+			UID:    "user-" + strconv.Itoa(i),
+			Role:   chat.RoomRoleMember.String(),
+		}
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 計算成員數
+	count, err := roomTestRepo.Count(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Equal(t, int64(5), count)
+}
+
+// ==================== User Interface 測試 ====================
+
+func TestRoomRepository_GetUserRooms(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建多個測試房間
+	rooms := make([]*entity.Room, 3)
+	for i := 0; i < 3; i++ {
+		room := &entity.Room{
+			Name:   "User Room " + strconv.Itoa(i),
+			Status: "active",
+		}
+		require.NoError(t, roomTestRepo.Create(ctx, room))
+		rooms[i] = room
+	}
+
+	// 將用戶加入多個房間
+	uid := "user-1"
+	for _, room := range rooms {
+		member := &entity.RoomMember{
+			RoomID: room.RoomID,
+			UID:    uid,
+			Role:   chat.RoomRoleMember.String(),
+		}
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 查詢用戶所在的所有房間
+	userRooms, err := roomTestRepo.GetUserRooms(ctx, uid)
+	require.NoError(t, err)
+	assert.Len(t, userRooms, 3)
+}
+
+func TestRoomRepository_CountUserRooms(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	rooms := make([]*entity.Room, 5)
+	for i := 0; i < 5; i++ {
+		room := &entity.Room{
+			Name:   "Count User Room " + strconv.Itoa(i),
+			Status: "active",
+		}
+		require.NoError(t, roomTestRepo.Create(ctx, room))
+		rooms[i] = room
+	}
+
+	// 將用戶加入多個房間
+	uid := "user-1"
+	for _, room := range rooms {
+		member := &entity.RoomMember{
+			RoomID: room.RoomID,
+			UID:    uid,
+			Role:   chat.RoomRoleMember.String(),
+		}
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 計算用戶所在的房間數
+	count, err := roomTestRepo.CountUserRooms(ctx, uid)
+	require.NoError(t, err)
+	assert.Equal(t, int64(5), count)
+}
+
+func TestRoomRepository_IsUserInRoom(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建測試房間
+	room := &entity.Room{
+		Name:   "Is User In Room Test",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	// 插入成員
+	member := &entity.RoomMember{
+		RoomID: room.RoomID,
+		UID:    "user-1",
+		Role:   chat.RoomRoleMember.String(),
+	}
+	require.NoError(t, roomTestRepo.Insert(ctx, member))
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	tests := []struct {
+		name    string
+		uid     string
+		roomID  string
+		want    bool
+		wantErr bool
+	}{
+		{
+			name:    "user in room",
+			uid:     "user-1",
+			roomID:  room.RoomID.String(),
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name:    "user not in room",
+			uid:     "user-2",
+			roomID:  room.RoomID.String(),
+			want:    false,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := roomTestRepo.IsUserInRoom(ctx, tt.uid, tt.roomID)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.want, result)
+			}
+		})
+	}
+}
+
+// ==================== 整合測試 ====================
+
+func TestRoomRepository_Integration(t *testing.T) {
+	ensureRoomRepository(t)
+	clearRoomData(t)
+	ctx := context.Background()
+
+	// 創建房間
+	room := &entity.Room{
+		Name:   "Integration Test Room",
+		Status: "active",
+	}
+	require.NoError(t, roomTestRepo.Create(ctx, room))
+
+	// 添加多個成員
+	members := []*entity.RoomMember{
+		{RoomID: room.RoomID, UID: "user-1", Role: chat.RoomRoleOwner.String()},
+		{RoomID: room.RoomID, UID: "user-2", Role: chat.RoomRoleAdmin.String()},
+		{RoomID: room.RoomID, UID: "user-3", Role: chat.RoomRoleMember.String()},
+	}
+
+	for _, member := range members {
+		require.NoError(t, roomTestRepo.Insert(ctx, member))
+	}
+
+	// 等待數據寫入
+	time.Sleep(100 * time.Millisecond)
+
+	// 驗證房間存在
+	exists, err := roomTestRepo.RoomExists(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.True(t, exists)
+
+	// 驗證成員數量
+	count, err := roomTestRepo.Count(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Equal(t, int64(3), count)
+
+	// 驗證所有成員
+	allMembers, err := roomTestRepo.AllMembers(ctx, room.RoomID.String())
+	require.NoError(t, err)
+	assert.Len(t, allMembers, 3)
+
+	// 驗證用戶所在的房間
+	for _, member := range members {
+		userRooms, err := roomTestRepo.GetUserRooms(ctx, member.UID)
+		require.NoError(t, err)
+		assert.Greater(t, len(userRooms), 0)
+
+		inRoom, err := roomTestRepo.IsUserInRoom(ctx, member.UID, room.RoomID.String())
+		require.NoError(t, err)
+		assert.True(t, inRoom)
+	}
+}
+

pkg/chat/usecase/message.go

@@ -0,0 +1,272 @@
+package usecase
+
+import (
+	"backend/pkg/chat/domain/entity"
+	"backend/pkg/chat/domain/repository"
+	"backend/pkg/chat/domain/usecase"
+	"backend/pkg/library/centrifugo"
+	errs "backend/pkg/library/errors"
+	"backend/pkg/utils"
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"time"
+
+	"github.com/gocql/gocql"
+	"github.com/google/uuid"
+)
+
+const (
+	defaultPageSize = 20
+	maxPageSize     = 100 // 設置最大分頁大小
+)
+
+type MessageUseCaseParam struct {
+	MessageRepo repository.MessageRepository
+	RoomRepo    repository.RoomRepository
+	MsgClient   *centrifugo.Client
+	Logger      errs.Logger
+}
+
+type MessageUseCase struct {
+	MessageUseCaseParam
+}
+
+// NewMessageUseCase 創建新的訊息 UseCase
+func NewMessageUseCase(param MessageUseCaseParam) usecase.MessageUseCase {
+	return &MessageUseCase{
+		param,
+	}
+}
+
+func (use *MessageUseCase) SendMessage(ctx context.Context, param usecase.SendMessageReq) error {
+	// 驗證輸入參數
+	if err := use.validateSendMessageReq(param); err != nil {
+		return err
+	}
+
+	// 驗證使用者是否在房間中（優先檢查，避免不必要的去重操作）
+	if err := use.verifyRoomMembership(ctx, param.UID, param.RoomID); err != nil {
+		return err
+	}
+
+	// 去重檢查
+	now := time.Now().UTC()
+	bucketSec := now.Unix()
+	contentMD5 := calculateMD5(param.Content)
+
+	isDuplicate, err := use.MessageRepo.CheckAndInsertDedup(ctx, repository.CheckDupReq{
+		RoomID:     param.RoomID,
+		UID:        param.UID, // 修復：應該是 param.UID 而不是 param.RoomID
+		BucketSec:  bucketSec,
+		ContentMD5: contentMD5,
+	})
+	if err != nil {
+		return use.logError("messageRepo.CheckAndInsertDedup", param, err, "failed to check message deduplication")
+	}
+
+	if isDuplicate {
+		return errs.InputInvalidFormatError("duplicate message detected")
+	}
+
+	// 建立並儲存訊息
+	msg, err := use.createMessage(param, now)
+	if err != nil {
+		return err
+	}
+
+	if err = use.MessageRepo.Insert(ctx, msg); err != nil {
+		return use.logError("messageRepo.Insert", param, err, "failed to insert message")
+	}
+
+	// 發布到 Centrifugo（非阻塞，失敗不影響主流程）
+	use.publishToCentrifugo(ctx, param.RoomID, msg, now)
+
+	return nil
+}
+
+// validateSendMessageReq 驗證發送訊息的請求參數
+func (use *MessageUseCase) validateSendMessageReq(param usecase.SendMessageReq) error {
+	if param.Content == "" {
+		return errs.InputInvalidFormatError("content cannot be empty")
+	}
+	if param.RoomID == "" {
+		return errs.InputInvalidFormatError("room_id cannot be empty")
+	}
+	if param.UID == "" {
+		return errs.InputInvalidFormatError("uid cannot be empty")
+	}
+	return nil
+}
+
+// verifyRoomMembership 驗證使用者是否在房間中
+func (use *MessageUseCase) verifyRoomMembership(ctx context.Context, uid, roomID string) error {
+	isMember, err := use.RoomRepo.IsUserInRoom(ctx, uid, roomID)
+	if err != nil {
+		return use.logError("roomRepo.IsUserInRoom", map[string]interface{}{
+			"uid":    uid,
+			"roomID": roomID,
+		}, err, "failed to check room membership")
+	}
+
+	if !isMember {
+		return errs.AuthForbiddenErrorL(
+			use.Logger,
+			[]errs.LogField{
+				{Key: "uid", Val: uid},
+				{Key: "roomID", Val: roomID},
+			},
+			"user is not a member of the room")
+	}
+
+	return nil
+}
+
+// createMessage 建立訊息實體
+func (use *MessageUseCase) createMessage(param usecase.SendMessageReq, now time.Time) (*entity.Message, error) {
+	roomID, err := gocql.ParseUUID(param.RoomID)
+	if err != nil {
+		return nil, errs.InputInvalidFormatError("invalid room_id format").Wrap(err)
+	}
+
+	msgID, err := uuid.NewV7()
+	if err != nil {
+		return nil, errs.SysInternalError("failed to generate message id").Wrap(err)
+	}
+
+	return &entity.Message{
+		RoomID:    roomID,
+		BucketDay: utils.GetBucketDay(now),
+		UID:       param.UID,
+		MsgID:     msgID,
+		Content:   param.Content,
+	}, nil
+}
+
+// publishToCentrifugo 發布訊息到 Centrifugo
+func (use *MessageUseCase) publishToCentrifugo(ctx context.Context, roomID string, msg *entity.Message, now time.Time) {
+	channel := fmt.Sprintf("room:%s", roomID)
+	messageData := map[string]interface{}{
+		"msg_id":    msg.MsgID.String(),
+		"uid":       msg.UID,
+		"content":   msg.Content,
+		"timestamp": now.UnixNano(), // 使用實際時間戳，而不是 msg.TS（可能為 0）
+		"room_id":   msg.RoomID.String(),
+	}
+
+	if _, err := use.MsgClient.PublishJSON(ctx, channel, messageData); err != nil {
+		// 記錄錯誤但不影響主流程，因為訊息已經成功儲存
+		if use.Logger != nil {
+			use.Logger.WithFields(
+				errs.LogField{Key: "roomID", Val: roomID},
+				errs.LogField{Key: "msgID", Val: msg.MsgID.String()},
+				errs.LogField{Key: "error", Val: err.Error()},
+			).Error(fmt.Sprintf("failed to publish message to Centrifugo: %v", err))
+		}
+	}
+}
+
+// logError 統一的錯誤記錄方法
+func (use *MessageUseCase) logError(funcName string, param interface{}, err error, message string) error {
+	return errs.DBErrorErrorL(
+		use.Logger,
+		[]errs.LogField{
+			{Key: "param", Val: param},
+			{Key: "func", Val: funcName},
+			{Key: "err", Val: err.Error()},
+		},
+		message)
+}
+
+func (use *MessageUseCase) ListMessages(ctx context.Context, req usecase.ListMessagesReq) ([]usecase.Message, int64, error) {
+	// 驗證輸入參數
+	if err := use.validateListMessagesReq(req); err != nil {
+		return nil, 0, err
+	}
+
+	// 驗證使用者是否在房間中
+	if err := use.verifyRoomMembership(ctx, req.UID, req.RoomID); err != nil {
+		return nil, 0, err
+	}
+
+	// 取得 bucket_day（如果未提供則使用今天）
+	bucketDay := req.BucketDay
+	if bucketDay == "" {
+		bucketDay = utils.GetTodayBucketDay()
+	}
+
+	// 防止 PageSize overflow 並設置合理的範圍
+	pageSize := use.normalizePageSize(req.PageSize)
+
+	// 查詢訊息
+	messages, err := use.MessageRepo.ListMessages(ctx, repository.ListMessagesReq{
+		RoomID:    req.RoomID,
+		BucketDay: bucketDay,
+		PageSize:  pageSize,
+		LastTS:    req.LastTS,
+	})
+	if err != nil {
+		return nil, 0, use.logError("messageRepo.ListMessages", req, err, "failed to list messages")
+	}
+
+	// 轉換為 usecase.Message
+	result := make([]usecase.Message, 0, len(messages))
+	for _, msg := range messages {
+		result = append(result, usecase.Message{
+			RoomID:    msg.RoomID.String(),
+			BucketDay: msg.BucketDay,
+			TS:        msg.TS,
+			UID:       msg.UID,
+			Content:   msg.Content,
+		})
+	}
+
+	// 計算總數（只在第一頁時計算）
+	var total int64
+	if req.LastTS == 0 {
+		total, err = use.MessageRepo.Count(ctx, req.RoomID)
+		if err != nil {
+			return nil, 0, use.logError("messageRepo.Count", req, err, "failed to count messages")
+		}
+	}
+
+	return result, total, nil
+}
+
+// validateListMessagesReq 驗證查詢訊息的請求參數
+func (use *MessageUseCase) validateListMessagesReq(req usecase.ListMessagesReq) error {
+	if req.RoomID == "" {
+		return errs.InputInvalidFormatError("room_id cannot be empty")
+	}
+	if req.UID == "" {
+		return errs.InputInvalidFormatError("uid cannot be empty")
+	}
+	return nil
+}
+
+// normalizePageSize 正規化分頁大小
+func (use *MessageUseCase) normalizePageSize(pageSize int64) int {
+	// 檢查是否超過 int 的最大值
+	if pageSize > int64(math.MaxInt) {
+		return maxPageSize
+	}
+
+	size := int(pageSize)
+	if size <= 0 {
+		return defaultPageSize
+	}
+
+	if size > maxPageSize {
+		return maxPageSize
+	}
+
+	return size
+}
+
+// calculateMD5 計算字串的 MD5 雜湊值
+func calculateMD5(content string) string {
+	hash := md5.Sum([]byte(content))
+	return hex.EncodeToString(hash[:])
+}

pkg/library/cassandra/query.go

@@ -75,6 +75,7 @@ type QueryBuilder[T Table] interface {
 	OrderBy(column string, order Order) QueryBuilder[T]
 	Limit(n int) QueryBuilder[T]
 	Select(columns ...string) QueryBuilder[T]
+	AllowFiltering() QueryBuilder[T]
 	Scan(ctx context.Context, dest *[]T) error
 	One(ctx context.Context) (T, error)
 	Count(ctx context.Context) (int64, error)
@@ -82,11 +83,12 @@ type QueryBuilder[T Table] interface {
 
 // queryBuilder 是 QueryBuilder 的具體實作
 type queryBuilder[T Table] struct {
-	repo       *repository[T]
+	repo           *repository[T]
-	conditions []Condition
+	conditions     []Condition
-	orders     []orderBy
+	orders         []orderBy
-	limit      int
+	limit          int
-	columns    []string
+	columns        []string
+	allowFiltering bool
 }
 
 type orderBy struct {
@@ -125,6 +127,12 @@ func (q *queryBuilder[T]) Select(columns ...string) QueryBuilder[T] {
 	return q
 }
 
+// AllowFiltering 允許不使用 partition key 的查詢（效能較差，慎用）
+func (q *queryBuilder[T]) AllowFiltering() QueryBuilder[T] {
+	q.allowFiltering = true
+	return q
+}
+
 // Scan 執行查詢並將結果掃描到 dest
 func (q *queryBuilder[T]) Scan(ctx context.Context, dest *[]T) error {
 	if dest == nil {
@@ -171,6 +179,11 @@ func (q *queryBuilder[T]) Scan(ctx context.Context, dest *[]T) error {
 		builder = builder.Limit(uint(q.limit))
 	}
 
+	// 添加 ALLOW FILTERING
+	if q.allowFiltering {
+		builder = builder.AllowFiltering()
+	}
+
 	stmt, names := builder.ToCql()
 	query := q.repo.db.withContextAndTimestamp(ctx,
 		q.repo.db.session.Query(stmt, names).BindMap(bindMap))
@@ -213,6 +226,11 @@ func (q *queryBuilder[T]) Count(ctx context.Context) (int64, error) {
 		builder = builder.Where(cmps...)
 	}
 
+	// 添加 ALLOW FILTERING
+	if q.allowFiltering {
+		builder = builder.AllowFiltering()
+	}
+
 	stmt, names := builder.ToCql()
 	query := q.repo.db.withContextAndTimestamp(ctx,
 		q.repo.db.session.Query(stmt, names).BindMap(bindMap))

pkg/library/cassandra/repository.go

@@ -130,8 +130,23 @@ func (r *repository[T]) updateSelective(ctx context.Context, doc T, includeZero
 func (r *repository[T]) Delete(ctx context.Context, pk any) error {
 	t := table.New(r.metadata)
 	stmt, names := t.Delete()
-	q := r.db.withContextAndTimestamp(ctx,
+
-		r.db.session.Query(stmt, names).Bind(pk))
+	// 如果 pk 是 struct，使用 BindStruct；否則使用 Bind
+	var q *gocqlx.Queryx
+	if reflect.TypeOf(pk).Kind() == reflect.Struct {
+		q = r.db.withContextAndTimestamp(ctx,
+			r.db.session.Query(stmt, names).BindStruct(pk))
+	} else {
+		// 單一主鍵欄位的情況
+		// 注意：這只適用於單一 Partition Key 且無 Clustering Key 的情況
+		if len(r.metadata.PartKey) != 1 || len(r.metadata.SortKey) > 0 {
+			return ErrInvalidInput.WithTable(r.table).WithError(
+				fmt.Errorf("single value primary key only supported for single partition key without clustering key"),
+			)
+		}
+		q = r.db.withContextAndTimestamp(ctx,
+			r.db.session.Query(stmt, names).Bind(pk))
+	}
 	return q.ExecRelease()
 }
 

pkg/library/centrifugo/README.md

@@ -0,0 +1,474 @@
+# Centrifugo Client Library
+
+Go 語言的 Centrifugo 即時訊息服務客戶端庫，提供完整的 Server-side API 支援。
+
+## 功能特色
+
+- ✅ **HTTP API 客戶端** - 發布訊息、訂閱管理、在線狀態、歷史訊息
+- ✅ **JWT Token 生成** - 連線認證和私有頻道訂閱
+- ✅ **Token 黑名單** - 撤銷單一 Token 或用戶所有 Token
+- ✅ **在線狀態追蹤** - Redis 存儲 + Centrifugo Presence API
+- ✅ **統一服務入口** - 簡單易用的 `Service` 整合介面
+
+## 安裝依賴
+
+```bash
+go get github.com/golang-jwt/jwt/v5
+go get github.com/zeromicro/go-zero/core/stores/redis
+```
+
+## 快速開始
+
+### 1. 創建服務實例（推薦方式）
+
+```go
+import (
+    "backend/pkg/library/centrifugo"
+    "github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+// 創建 Redis 客戶端
+rds, _ := redis.NewRedis(redis.RedisConf{
+    Host: "localhost:6379",
+    Type: "node",
+})
+
+// 創建 Centrifugo 服務
+svc := centrifugo.NewService(centrifugo.ServiceConfig{
+    APIURL:      "http://localhost:8000",
+    APIKey:      "your-api-key",
+    TokenSecret: "your-jwt-secret",
+    Redis:       rds, // 可選，用於黑名單和在線狀態
+})
+```
+
+### 2. 發布訊息
+
+```go
+ctx := context.Background()
+
+// 方法 1: 使用 Service 便捷方法
+result, err := svc.PublishJSON(ctx, "chat:room-123", map[string]interface{}{
+    "message": "Hello, World!",
+    "user":    "daniel",
+})
+
+// 方法 2: 使用 Client 直接調用
+result, err := svc.Client().Publish(ctx, "chat:room-123", []byte(`{"message": "Hello!"}`))
+
+// 批量發布到多個頻道
+channels := []string{"user:1", "user:2", "user:3"}
+err := svc.BroadcastJSON(ctx, channels, map[string]string{
+    "type":    "notification",
+    "message": "System maintenance",
+})
+```
+
+### 3. Token 生成
+
+```go
+// 快速生成連線 Token
+token, err := svc.GenerateToken("user-123")
+
+// 生成帶用戶資訊的 Token
+token, err := svc.GenerateTokenWithInfo("user-123", map[string]interface{}{
+    "name":   "Daniel",
+    "avatar": "https://example.com/avatar.jpg",
+})
+
+// 完整選項
+token, err := svc.Token().GenerateConnectionToken(centrifugo.ConnectionTokenOptions{
+    UserID:   "user-123",
+    Info:     map[string]interface{}{"role": "admin"},
+    Channels: []string{"chat:room-1", "chat:room-2"}, // 自動訂閱
+})
+
+// 訂閱 Token（用於私有頻道）
+token, err := svc.Token().QuickSubscriptionToken("user-123", "private:room-456")
+```
+
+### 4. 撤銷 Token（踢人）
+
+```go
+// 最常用：撤銷用戶所有 Token 並斷開連線
+// 適用於：用戶被封禁、密碼變更、用戶登出全部設備
+err := svc.InvalidateUser(ctx, "user-123")
+
+// 只斷開連線（不撤銷 Token）
+err := svc.Disconnect(ctx, "user-123")
+
+// 撤銷特定 Token（需要 JTI）
+err := svc.Blacklist().RevokeToken(ctx, jti, time.Hour)
+
+// 撤銷用戶所有 Token（不斷開連線）
+err := svc.Blacklist().RevokeUserTokens(ctx, "user-123")
+```
+
+### 5. 在線狀態追蹤
+
+```go
+// 檢查單一用戶是否在線
+online, err := svc.IsUserOnline(ctx, "user-123")
+
+// 批量獲取在線狀態
+status, err := svc.GetUsersOnlineStatus(ctx, []string{"user-1", "user-2", "user-3"})
+// status = map[string]bool{"user-1": true, "user-2": false, "user-3": true}
+
+// 處理 Centrifugo Connect/Disconnect Proxy 事件
+svc.Online().HandleConnect(ctx, "user-123")
+svc.Online().HandleDisconnect(ctx, "user-123")
+
+// 使用 Centrifugo Presence API（頻道級別）
+users, err := svc.Online().GetChannelOnlineUsers(ctx, "chat:room-123")
+stats, err := svc.Online().GetChannelStats(ctx, "chat:room-123")
+```
+
+---
+
+## 獨立使用各元件
+
+如果不需要完整的 Service，可以獨立使用各元件：
+
+### HTTP API Client
+
+```go
+// 創建客戶端
+client := centrifugo.NewClient("http://localhost:8000", "your-api-key")
+
+// 使用自定義配置
+client := centrifugo.NewClientWithConfig(centrifugo.ClientConfig{
+    APIURL:              "http://localhost:8000",
+    APIKey:              "your-api-key",
+    Timeout:             5 * time.Second,
+    MaxIdleConns:        200,
+    MaxIdleConnsPerHost: 50,
+})
+
+// API 調用
+client.Publish(ctx, channel, data)
+client.PublishJSON(ctx, channel, data)
+client.Broadcast(ctx, channels, data)
+client.Subscribe(ctx, user, channel)
+client.Unsubscribe(ctx, user, channel)
+client.Disconnect(ctx, user)
+client.DisconnectWithCode(ctx, user, code, reason)
+client.Presence(ctx, channel)
+client.PresenceStats(ctx, channel)
+client.History(ctx, channel, limit)
+client.HistoryReverse(ctx, channel, limit)
+client.Channels(ctx)
+client.ChannelsWithPattern(ctx, pattern)
+client.Info(ctx)
+client.Ping(ctx)
+```
+
+### Token Generator
+
+```go
+// 創建生成器
+tokenGen := centrifugo.NewTokenGenerator("your-jwt-secret")
+
+// 使用自定義配置
+tokenGen := centrifugo.NewTokenGeneratorWithConfig(centrifugo.TokenConfig{
+    Secret:   "your-jwt-secret",
+    ExpireIn: 24 * time.Hour,
+})
+
+// 生成 Token
+tokenGen.QuickConnectionToken(userID)
+tokenGen.QuickSubscriptionToken(userID, channel)
+tokenGen.GenerateConnectionToken(opts)
+tokenGen.GenerateSubscriptionToken(opts)
+tokenGen.GenerateAnonymousToken()
+```
+
+### Token Blacklist
+
+```go
+// 創建黑名單管理器
+blacklist := centrifugo.NewTokenBlacklist(redisClient)
+
+// 撤銷操作
+blacklist.RevokeToken(ctx, jti, ttl)         // 撤銷單一 Token
+blacklist.RevokeUserTokens(ctx, userID)       // 撤銷用戶所有 Token
+
+// 驗證操作
+blacklist.IsTokenRevoked(ctx, jti)            // 檢查 Token 是否被撤銷
+blacklist.GetUserTokenVersion(ctx, userID)    // 獲取用戶 Token 版本
+blacklist.IsTokenVersionValid(ctx, userID, v) // 檢查版本是否有效
+```
+
+### Online Manager
+
+```go
+// 創建管理器
+store := centrifugo.NewRedisOnlineStore(redisClient)
+onlineManager := centrifugo.NewOnlineManagerWithTTL(client, store, 5*time.Minute)
+
+// Redis 存儲操作
+onlineManager.HandleConnect(ctx, userID)
+onlineManager.HandleDisconnect(ctx, userID)
+onlineManager.IsUserOnline(ctx, userID)
+onlineManager.GetUsersOnlineStatus(ctx, userIDs)
+onlineManager.RefreshOnline(ctx, userID)
+
+// Centrifugo Presence API
+onlineManager.IsUserInChannel(ctx, userID, channel)
+onlineManager.GetChannelOnlineUsers(ctx, channel)
+onlineManager.GetChannelStats(ctx, channel)
+```
+
+---
+
+## 前端整合範例
+
+### JavaScript (使用 centrifuge-js)
+
+```javascript
+import { Centrifuge } from 'centrifuge';
+
+// 從後端 API 獲取 Token
+const getToken = async () => {
+    const response = await fetch('/api/centrifugo/token');
+    const data = await response.json();
+    return data.token;
+};
+
+// 創建連線
+const centrifuge = new Centrifuge('ws://localhost:8000/connection/websocket', {
+    getToken: getToken,
+});
+
+// 訂閱頻道
+const sub = centrifuge.newSubscription('chat:room-123');
+sub.on('publication', (ctx) => {
+    console.log('Received:', ctx.data);
+});
+sub.subscribe();
+
+// 連線
+centrifuge.connect();
+```
+
+### 後端 Token API
+
+```go
+// handlers/centrifugo.go
+func (h *Handler) GetConnectionToken(c *gin.Context) {
+    userID := c.GetString("user_id") // 從 JWT 或 session 獲取
+    
+    token, err := h.svc.GenerateToken(userID)
+    if err != nil {
+        c.JSON(500, gin.H{"error": "failed to generate token"})
+        return
+    }
+    
+    c.JSON(200, gin.H{"token": token})
+}
+
+func (h *Handler) GetSubscriptionToken(c *gin.Context) {
+    userID := c.GetString("user_id")
+    channel := c.Query("channel")
+    
+    // 驗證用戶是否有權限訂閱此頻道
+    if !h.canSubscribe(userID, channel) {
+        c.JSON(403, gin.H{"error": "forbidden"})
+        return
+    }
+    
+    token, err := h.svc.Token().QuickSubscriptionToken(userID, channel)
+    if err != nil {
+        c.JSON(500, gin.H{"error": "failed to generate token"})
+        return
+    }
+    
+    c.JSON(200, gin.H{"token": token})
+}
+```
+
+---
+
+## Centrifugo Proxy 整合
+
+### Connect Proxy
+
+```go
+// POST /centrifugo/connect
+func (h *Handler) CentrifugoConnect(c *gin.Context) {
+    var req struct {
+        Client    string `json:"client"`
+        Transport string `json:"transport"`
+        Protocol  string `json:"protocol"`
+        Data      []byte `json:"data"`
+    }
+    c.BindJSON(&req)
+    
+    // 從 Token 驗證用戶（Centrifugo 會傳遞）
+    userID := extractUserID(req.Data)
+    
+    // 記錄連線
+    h.svc.Online().HandleConnect(c, userID)
+    
+    c.JSON(200, gin.H{
+        "result": map[string]interface{}{
+            "user": userID,
+        },
+    })
+}
+```
+
+### Disconnect Proxy
+
+```go
+// POST /centrifugo/disconnect
+func (h *Handler) CentrifugoDisconnect(c *gin.Context) {
+    var req struct {
+        Client string `json:"client"`
+        User   string `json:"user"`
+    }
+    c.BindJSON(&req)
+    
+    // 記錄離線
+    h.svc.Online().HandleDisconnect(c, req.User)
+    
+    c.JSON(200, gin.H{"result": map[string]interface{}{}})
+}
+```
+
+---
+
+## Centrifugo 配置參考
+
+```json
+{
+  "token_hmac_secret_key": "your-jwt-secret",
+  "api_key": "your-api-key",
+  "admin": true,
+  "allowed_origins": ["http://localhost:3000"],
+  "proxy_connect_endpoint": "http://localhost:8080/centrifugo/connect",
+  "proxy_disconnect_endpoint": "http://localhost:8080/centrifugo/disconnect",
+  "namespaces": [
+    {
+      "name": "chat",
+      "presence": true,
+      "history_size": 100,
+      "history_ttl": "300s"
+    },
+    {
+      "name": "private",
+      "presence": true,
+      "protected": true
+    }
+  ]
+}
+```
+
+---
+
+## API 參考
+
+### Service 方法
+
+| 方法 | 說明 |
+|------|------|
+| `Client()` | 返回 HTTP API 客戶端 |
+| `Token()` | 返回 Token 生成器 |
+| `Blacklist()` | 返回黑名單管理器（可能為 nil） |
+| `Online()` | 返回在線狀態管理器（可能為 nil） |
+| `PublishJSON(ctx, channel, data)` | 發布 JSON 訊息 |
+| `BroadcastJSON(ctx, channels, data)` | 批量發布 JSON 訊息 |
+| `Disconnect(ctx, userID)` | 斷開用戶連線 |
+| `GenerateToken(userID)` | 快速生成連線 Token |
+| `GenerateTokenWithInfo(userID, info)` | 生成帶資訊的連線 Token |
+| `InvalidateUser(ctx, userID)` | 撤銷所有 Token 並斷開連線 |
+| `IsUserOnline(ctx, userID)` | 檢查用戶是否在線 |
+| `GetUsersOnlineStatus(ctx, userIDs)` | 批量獲取在線狀態 |
+
+### Client 方法
+
+| 方法 | 說明 | 返回值 |
+|------|------|--------|
+| `Publish(ctx, channel, data)` | 發布訊息 | `*PublishResult, error` |
+| `PublishJSON(ctx, channel, data)` | 發布 JSON | `*PublishResult, error` |
+| `Broadcast(ctx, channels, data)` | 批量發布 | `error` |
+| `BroadcastJSON(ctx, channels, data)` | 批量發布 JSON | `error` |
+| `Subscribe(ctx, user, channel)` | 訂閱用戶 | `error` |
+| `Unsubscribe(ctx, user, channel)` | 取消訂閱 | `error` |
+| `Disconnect(ctx, user)` | 斷開連線 | `error` |
+| `DisconnectWithCode(ctx, user, code, reason)` | 帶代碼斷開連線 | `error` |
+| `Presence(ctx, channel)` | 在線用戶 | `*PresenceResult, error` |
+| `PresenceStats(ctx, channel)` | 在線統計 | `*PresenceStatsResult, error` |
+| `History(ctx, channel, limit)` | 歷史訊息 | `*HistoryResult, error` |
+| `HistoryReverse(ctx, channel, limit)` | 歷史訊息（倒序） | `*HistoryResult, error` |
+| `Channels(ctx)` | 活躍頻道 | `*ChannelsResult, error` |
+| `ChannelsWithPattern(ctx, pattern)` | 匹配頻道 | `*ChannelsResult, error` |
+| `Info(ctx)` | 伺服器資訊 | `*InfoResult, error` |
+| `Ping(ctx)` | 健康檢查 | `error` |
+
+### TokenGenerator 方法
+
+| 方法 | 說明 |
+|------|------|
+| `GenerateConnectionToken(opts)` | 生成連線 Token（完整選項） |
+| `GenerateSubscriptionToken(opts)` | 生成訂閱 Token（完整選項） |
+| `GenerateAnonymousToken()` | 生成匿名 Token |
+| `QuickConnectionToken(userID)` | 快速生成連線 Token |
+| `QuickSubscriptionToken(userID, channel)` | 快速生成訂閱 Token |
+
+### TokenBlacklist 方法
+
+| 方法 | 說明 |
+|------|------|
+| `RevokeToken(ctx, jti, ttl)` | 撤銷特定 Token |
+| `RevokeUserTokens(ctx, userID)` | 撤銷用戶所有 Token |
+| `IsTokenRevoked(ctx, jti)` | 檢查 Token 是否被撤銷 |
+| `GetUserTokenVersion(ctx, userID)` | 獲取用戶 Token 版本 |
+| `IsTokenVersionValid(ctx, userID, version)` | 檢查版本是否有效 |
+
+---
+
+## 錯誤處理
+
+```go
+result, err := svc.Client().Publish(ctx, channel, data)
+if err != nil {
+    // 檢查是否為 Centrifugo API 錯誤
+    if apiErr, ok := err.(*centrifugo.APIError); ok {
+        fmt.Printf("Centrifugo error code: %d, message: %s\n", 
+            apiErr.Code, apiErr.Message)
+    } else {
+        // 網路錯誤或其他錯誤
+        fmt.Printf("Error: %v\n", err)
+    }
+}
+
+// 檢查特定錯誤
+if errors.Is(err, centrifugo.ErrBlacklistNotConfigured) {
+    // 黑名單未配置
+}
+if errors.Is(err, centrifugo.ErrOnlineStoreNotConfigured) {
+    // 在線狀態存儲未配置
+}
+```
+
+---
+
+## 檔案結構
+
+```
+pkg/library/centrifugo/
+├── centrifugo.go      # 主入口，Service 整合介面
+├── client.go          # HTTP API 客戶端
+├── token.go           # JWT Token 生成器
+├── blacklist.go       # Token 黑名單管理
+├── online.go          # 在線狀態管理介面
+├── online_redis.go    # Redis 在線狀態實作
+├── README.md          # 文檔
+└── *_test.go          # 測試文件
+```
+
+---
+
+## License
+
+MIT

pkg/library/centrifugo/blacklist.go

@@ -0,0 +1,130 @@
+package centrifugo
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+// 錯誤定義
+var (
+	ErrBlacklistNotConfigured   = errors.New("token blacklist is not configured")
+	ErrOnlineStoreNotConfigured = errors.New("online store is not configured")
+)
+
+// TokenBlacklist Token 黑名單管理器
+// 提供兩種撤銷機制：
+//  1. 單一 Token 撤銷：使用 JTI（JWT ID）將特定 Token 加入黑名單
+//  2. 用戶全部撤銷：使用版本號機制，使用戶之前所有 Token 失效
+type TokenBlacklist struct {
+	redis  *redis.Redis
+	prefix string
+}
+
+// NewTokenBlacklist 創建 Token 黑名單管理器
+func NewTokenBlacklist(redisClient *redis.Redis) *TokenBlacklist {
+	return &TokenBlacklist{
+		redis:  redisClient,
+		prefix: "centrifugo:blacklist:",
+	}
+}
+
+// NewTokenBlacklistWithPrefix 創建帶自定義前綴的 Token 黑名單管理器
+func NewTokenBlacklistWithPrefix(redisClient *redis.Redis, prefix string) *TokenBlacklist {
+	return &TokenBlacklist{
+		redis:  redisClient,
+		prefix: prefix,
+	}
+}
+
+// ==================== 撤銷操作 ====================
+
+// RevokeToken 撤銷特定 Token（使用 JTI）
+// ttl: 黑名單過期時間，應設置為 Token 的剩餘有效時間
+//
+// 使用場景：
+//   - 用戶登出單一設備
+//   - 檢測到可疑活動的特定 session
+func (b *TokenBlacklist) RevokeToken(ctx context.Context, jti string, ttl time.Duration) error {
+	if jti == "" {
+		return errors.New("jti cannot be empty")
+	}
+	key := b.tokenKey(jti)
+	return b.redis.SetexCtx(ctx, key, "revoked", int(ttl.Seconds()))
+}
+
+// RevokeUserTokens 撤銷用戶的所有 Token（使用版本控制）
+// 通過更新版本號，使該用戶之前發出的所有 Token 失效
+//
+// 使用場景：
+//   - 用戶被封禁
+//   - 密碼變更
+//   - 用戶主動登出全部設備
+func (b *TokenBlacklist) RevokeUserTokens(ctx context.Context, userID string) error {
+	if userID == "" {
+		return errors.New("userID cannot be empty")
+	}
+	key := b.userVersionKey(userID)
+	version := time.Now().UnixNano()
+	// 設置 7 天過期，足夠長於任何 Token 的有效期
+	return b.redis.SetexCtx(ctx, key, fmt.Sprintf("%d", version), 7*24*3600)
+}
+
+// ==================== 驗證操作 ====================
+
+// IsTokenRevoked 檢查 Token 是否被撤銷（使用 JTI）
+func (b *TokenBlacklist) IsTokenRevoked(ctx context.Context, jti string) (bool, error) {
+	if jti == "" {
+		return false, nil
+	}
+	key := b.tokenKey(jti)
+	exists, err := b.redis.ExistsCtx(ctx, key)
+	if err != nil {
+		return false, err
+	}
+	return exists, nil
+}
+
+// GetUserTokenVersion 獲取用戶的 Token 版本
+// 返回 0 表示沒有設置版本（用戶從未被撤銷過）
+func (b *TokenBlacklist) GetUserTokenVersion(ctx context.Context, userID string) (int64, error) {
+	if userID == "" {
+		return 0, nil
+	}
+	key := b.userVersionKey(userID)
+	val, err := b.redis.GetCtx(ctx, key)
+	if err != nil {
+		return 0, err
+	}
+	if val == "" {
+		return 0, nil
+	}
+	var version int64
+	_, err = fmt.Sscanf(val, "%d", &version)
+	return version, err
+}
+
+// IsTokenVersionValid 檢查 Token 版本是否有效
+// tokenVersion: Token 內嵌的版本號
+// 如果 currentVersion > tokenVersion，表示 Token 已被撤銷
+func (b *TokenBlacklist) IsTokenVersionValid(ctx context.Context, userID string, tokenVersion int64) (bool, error) {
+	currentVersion, err := b.GetUserTokenVersion(ctx, userID)
+	if err != nil {
+		return false, err
+	}
+	// 如果沒有設置版本，或 Token 版本 >= 當前版本，則有效
+	return currentVersion == 0 || tokenVersion >= currentVersion, nil
+}
+
+// ==================== Key 生成 ====================
+
+func (b *TokenBlacklist) tokenKey(jti string) string {
+	return b.prefix + "token:" + jti
+}
+
+func (b *TokenBlacklist) userVersionKey(userID string) string {
+	return b.prefix + "user_version:" + userID
+}

pkg/library/centrifugo/blacklist_test.go

@@ -0,0 +1,246 @@
+package centrifugo
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+func setupTestRedis(t *testing.T) (*redis.Redis, func()) {
+	mr, err := miniredis.Run()
+	require.NoError(t, err)
+
+	rds, err := redis.NewRedis(redis.RedisConf{
+		Host: mr.Addr(),
+		Type: "node",
+	})
+	require.NoError(t, err)
+
+	return rds, func() {
+		mr.Close()
+	}
+}
+
+func TestNewTokenBlacklist(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+
+	assert.NotNil(t, blacklist)
+	assert.Equal(t, "centrifugo:blacklist:", blacklist.prefix)
+}
+
+func TestNewTokenBlacklistWithPrefix(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklistWithPrefix(rds, "custom:prefix:")
+
+	assert.NotNil(t, blacklist)
+	assert.Equal(t, "custom:prefix:", blacklist.prefix)
+}
+
+func TestRevokeToken(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	jti := "test-jti-123"
+	ttl := 1 * time.Hour
+
+	// 撤銷 Token
+	err := blacklist.RevokeToken(ctx, jti, ttl)
+	require.NoError(t, err)
+
+	// 檢查是否被撤銷
+	revoked, err := blacklist.IsTokenRevoked(ctx, jti)
+	require.NoError(t, err)
+	assert.True(t, revoked)
+}
+
+func TestRevokeToken_EmptyJTI(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	err := blacklist.RevokeToken(ctx, "", time.Hour)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "jti cannot be empty")
+}
+
+func TestIsTokenRevoked_NotRevoked(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	// 檢查未撤銷的 Token
+	revoked, err := blacklist.IsTokenRevoked(ctx, "non-existent-jti")
+	require.NoError(t, err)
+	assert.False(t, revoked)
+}
+
+func TestIsTokenRevoked_EmptyJTI(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	// 空 JTI 應該返回 false
+	revoked, err := blacklist.IsTokenRevoked(ctx, "")
+	require.NoError(t, err)
+	assert.False(t, revoked)
+}
+
+func TestRevokeUserTokens(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 撤銷用戶所有 Token
+	err := blacklist.RevokeUserTokens(ctx, userID)
+	require.NoError(t, err)
+
+	// 獲取版本
+	version, err := blacklist.GetUserTokenVersion(ctx, userID)
+	require.NoError(t, err)
+	assert.Greater(t, version, int64(0))
+}
+
+func TestRevokeUserTokens_EmptyUserID(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	err := blacklist.RevokeUserTokens(ctx, "")
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "userID cannot be empty")
+}
+
+func TestGetUserTokenVersion_NoVersion(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	// 未設置版本的用戶應該返回 0
+	version, err := blacklist.GetUserTokenVersion(ctx, "new-user")
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), version)
+}
+
+func TestGetUserTokenVersion_EmptyUserID(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	version, err := blacklist.GetUserTokenVersion(ctx, "")
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), version)
+}
+
+func TestIsTokenVersionValid(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 未設置版本時，任何版本都應該有效
+	valid, err := blacklist.IsTokenVersionValid(ctx, userID, 0)
+	require.NoError(t, err)
+	assert.True(t, valid)
+
+	// 撤銷用戶 Token
+	err = blacklist.RevokeUserTokens(ctx, userID)
+	require.NoError(t, err)
+
+	// 獲取當前版本
+	currentVersion, err := blacklist.GetUserTokenVersion(ctx, userID)
+	require.NoError(t, err)
+
+	// 舊版本應該無效
+	valid, err = blacklist.IsTokenVersionValid(ctx, userID, currentVersion-1)
+	require.NoError(t, err)
+	assert.False(t, valid)
+
+	// 當前版本應該有效
+	valid, err = blacklist.IsTokenVersionValid(ctx, userID, currentVersion)
+	require.NoError(t, err)
+	assert.True(t, valid)
+
+	// 更新版本應該有效
+	valid, err = blacklist.IsTokenVersionValid(ctx, userID, currentVersion+1)
+	require.NoError(t, err)
+	assert.True(t, valid)
+}
+
+func TestRevokeUserTokens_MultipleRevokes(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklist(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 第一次撤銷
+	err := blacklist.RevokeUserTokens(ctx, userID)
+	require.NoError(t, err)
+
+	version1, err := blacklist.GetUserTokenVersion(ctx, userID)
+	require.NoError(t, err)
+
+	// 等待一點時間確保時間戳不同
+	time.Sleep(10 * time.Millisecond)
+
+	// 第二次撤銷
+	err = blacklist.RevokeUserTokens(ctx, userID)
+	require.NoError(t, err)
+
+	version2, err := blacklist.GetUserTokenVersion(ctx, userID)
+	require.NoError(t, err)
+
+	// 第二次的版本應該更大
+	assert.Greater(t, version2, version1)
+
+	// 第一次的版本應該已經無效
+	valid, err := blacklist.IsTokenVersionValid(ctx, userID, version1)
+	require.NoError(t, err)
+	assert.False(t, valid)
+}
+
+func TestKeyGeneration(t *testing.T) {
+	rds, cleanup := setupTestRedis(t)
+	defer cleanup()
+
+	blacklist := NewTokenBlacklistWithPrefix(rds, "test:")
+
+	// 測試 key 生成
+	assert.Equal(t, "test:token:jti-123", blacklist.tokenKey("jti-123"))
+	assert.Equal(t, "test:user_version:user-456", blacklist.userVersionKey("user-456"))
+}
+

pkg/library/centrifugo/centrifugo.go

@@ -0,0 +1,188 @@
+// Package centrifugo 提供 Centrifugo 即時訊息服務的完整 Go 客戶端
+//
+// 功能包含:
+//   - HTTP API 客戶端（發布訊息、訂閱管理、在線狀態等）
+//   - JWT Token 生成（連線認證、私有頻道訂閱）
+//   - Token 黑名單管理（撤銷單一 Token、撤銷用戶所有 Token）
+//   - 在線狀態追蹤（Redis 或記憶體存儲）
+//
+// 基本使用:
+//
+//	// 創建服務實例
+//	svc := centrifugo.NewService(centrifugo.ServiceConfig{
+//	    APIURL:      "http://localhost:8000",
+//	    APIKey:      "your-api-key",
+//	    TokenSecret: "your-jwt-secret",
+//	    Redis:       redisClient, // 可選，用於黑名單和在線狀態
+//	})
+//
+//	// 發布訊息
+//	svc.Client().PublishJSON(ctx, "chat:room-1", data)
+//
+//	// 生成 Token
+//	token, _ := svc.Token().QuickConnectionToken("user-123")
+//
+//	// 撤銷用戶所有 Token 並踢出
+//	svc.InvalidateUser(ctx, "user-123")
+package centrifugo
+
+import (
+	"context"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+// Service Centrifugo 服務整合介面
+// 提供 HTTP API、Token 生成、黑名單管理、在線狀態追蹤的統一入口
+type Service struct {
+	client    *Client
+	token     *TokenGenerator
+	blacklist *TokenBlacklist
+	online    *OnlineManager
+}
+
+// ServiceConfig 服務配置
+type ServiceConfig struct {
+	// APIURL Centrifugo HTTP API 地址（必填）
+	APIURL string
+	// APIKey Centrifugo API 密鑰（必填）
+	APIKey string
+	// TokenSecret JWT Token 簽名密鑰（必填）
+	TokenSecret string
+	// TokenExpire Token 過期時間（預設 1 小時）
+	TokenExpire time.Duration
+	// Redis 客戶端（可選，用於黑名單和在線狀態）
+	Redis *redis.Redis
+	// ClientConfig HTTP 客戶端配置（可選）
+	ClientConfig *ClientConfig
+	// OnlineTTL 在線狀態過期時間（預設 5 分鐘）
+	OnlineTTL time.Duration
+	// KeyPrefix Redis key 前綴（預設 "centrifugo:"）
+	KeyPrefix string
+}
+
+// NewService 創建 Centrifugo 服務實例
+func NewService(cfg ServiceConfig) *Service {
+	// 設定預設值
+	if cfg.TokenExpire == 0 {
+		cfg.TokenExpire = time.Hour
+	}
+	if cfg.OnlineTTL == 0 {
+		cfg.OnlineTTL = 5 * time.Minute
+	}
+	if cfg.KeyPrefix == "" {
+		cfg.KeyPrefix = "centrifugo:"
+	}
+
+	// 創建 HTTP 客戶端
+	var client *Client
+	if cfg.ClientConfig != nil {
+		client = NewClientWithConfig(*cfg.ClientConfig)
+	} else {
+		client = NewClient(cfg.APIURL, cfg.APIKey)
+	}
+
+	// 創建 Token 生成器
+	token := NewTokenGeneratorWithConfig(TokenConfig{
+		Secret:   cfg.TokenSecret,
+		ExpireIn: cfg.TokenExpire,
+	})
+
+	svc := &Service{
+		client: client,
+		token:  token,
+	}
+
+	// 如果有 Redis，創建黑名單管理器和在線狀態管理器
+	if cfg.Redis != nil {
+		svc.blacklist = NewTokenBlacklistWithPrefix(cfg.Redis, cfg.KeyPrefix+"blacklist:")
+		store := NewRedisOnlineStoreWithPrefix(cfg.Redis, cfg.KeyPrefix+"online:")
+		svc.online = NewOnlineManagerWithTTL(client, store, cfg.OnlineTTL)
+	}
+
+	return svc
+}
+
+// Client 返回 HTTP API 客戶端
+func (s *Service) Client() *Client {
+	return s.client
+}
+
+// Token 返回 Token 生成器
+func (s *Service) Token() *TokenGenerator {
+	return s.token
+}
+
+// Blacklist 返回黑名單管理器（可能為 nil）
+func (s *Service) Blacklist() *TokenBlacklist {
+	return s.blacklist
+}
+
+// Online 返回在線狀態管理器（可能為 nil）
+func (s *Service) Online() *OnlineManager {
+	return s.online
+}
+
+// ==================== 便捷方法 ====================
+
+// PublishJSON 發布 JSON 訊息到頻道
+func (s *Service) PublishJSON(ctx context.Context, channel string, data interface{}) (*PublishResult, error) {
+	return s.client.PublishJSON(ctx, channel, data)
+}
+
+// BroadcastJSON 批量發布 JSON 訊息到多個頻道
+func (s *Service) BroadcastJSON(ctx context.Context, channels []string, data interface{}) error {
+	return s.client.BroadcastJSON(ctx, channels, data)
+}
+
+// Disconnect 斷開用戶連線
+func (s *Service) Disconnect(ctx context.Context, userID string) error {
+	return s.client.Disconnect(ctx, userID)
+}
+
+// GenerateToken 快速生成連線 Token
+func (s *Service) GenerateToken(userID string) (string, error) {
+	return s.token.QuickConnectionToken(userID)
+}
+
+// GenerateTokenWithInfo 生成帶用戶資訊的連線 Token
+func (s *Service) GenerateTokenWithInfo(userID string, info map[string]interface{}) (string, error) {
+	return s.token.GenerateConnectionToken(ConnectionTokenOptions{
+		UserID: userID,
+		Info:   info,
+	})
+}
+
+// InvalidateUser 撤銷用戶所有 Token 並斷開連線
+// 這是最常用的「踢人」方法，適用於：
+//   - 用戶被封禁
+//   - 密碼變更
+//   - 用戶登出（全設備）
+func (s *Service) InvalidateUser(ctx context.Context, userID string) error {
+	// 撤銷所有 Token
+	if s.blacklist != nil {
+		if err := s.blacklist.RevokeUserTokens(ctx, userID); err != nil {
+			return err
+		}
+	}
+	// 斷開連線
+	return s.client.Disconnect(ctx, userID)
+}
+
+// IsUserOnline 檢查用戶是否在線
+func (s *Service) IsUserOnline(ctx context.Context, userID string) (bool, error) {
+	if s.online == nil {
+		return false, ErrOnlineStoreNotConfigured
+	}
+	return s.online.IsUserOnline(ctx, userID)
+}
+
+// GetUsersOnlineStatus 批量獲取用戶在線狀態
+func (s *Service) GetUsersOnlineStatus(ctx context.Context, userIDs []string) (map[string]bool, error) {
+	if s.online == nil {
+		return nil, ErrOnlineStoreNotConfigured
+	}
+	return s.online.GetUsersOnlineStatus(ctx, userIDs)
+}
+

pkg/library/centrifugo/centrifugo_test.go

@@ -0,0 +1,303 @@
+package centrifugo
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+func setupServiceTestRedis(t *testing.T) (*redis.Redis, func()) {
+	mr, err := miniredis.Run()
+	require.NoError(t, err)
+
+	rds, err := redis.NewRedis(redis.RedisConf{
+		Host: mr.Addr(),
+		Type: "node",
+	})
+	require.NoError(t, err)
+
+	return rds, func() {
+		mr.Close()
+	}
+}
+
+func TestNewService(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       rds,
+	})
+
+	assert.NotNil(t, svc)
+	assert.NotNil(t, svc.Client())
+	assert.NotNil(t, svc.Token())
+	assert.NotNil(t, svc.Blacklist())
+	assert.NotNil(t, svc.Online())
+}
+
+func TestNewService_WithoutRedis(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       nil, // 沒有 Redis
+	})
+
+	assert.NotNil(t, svc)
+	assert.NotNil(t, svc.Client())
+	assert.NotNil(t, svc.Token())
+	assert.Nil(t, svc.Blacklist()) // 應該為 nil
+	assert.Nil(t, svc.Online())    // 應該為 nil
+}
+
+func TestNewService_DefaultValues(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+	})
+
+	assert.NotNil(t, svc)
+	// 檢查預設值已被應用（通過生成 Token 間接驗證）
+	token, err := svc.GenerateToken("user-123")
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+}
+
+func TestNewService_WithCustomConfig(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	customExpire := 24 * time.Hour
+	customTTL := 10 * time.Minute
+	customPrefix := "custom:"
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		TokenExpire: customExpire,
+		Redis:       rds,
+		OnlineTTL:   customTTL,
+		KeyPrefix:   customPrefix,
+	})
+
+	assert.NotNil(t, svc)
+}
+
+func TestService_GenerateToken(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+	})
+
+	token, err := svc.GenerateToken("user-123")
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+}
+
+func TestService_GenerateTokenWithInfo(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+	})
+
+	info := map[string]interface{}{
+		"name":   "Daniel",
+		"avatar": "https://example.com/avatar.jpg",
+	}
+
+	token, err := svc.GenerateTokenWithInfo("user-123", info)
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+}
+
+func TestService_IsUserOnline_WithoutRedis(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       nil,
+	})
+
+	_, err := svc.IsUserOnline(context.Background(), "user-123")
+
+	assert.Error(t, err)
+	assert.ErrorIs(t, err, ErrOnlineStoreNotConfigured)
+}
+
+func TestService_GetUsersOnlineStatus_WithoutRedis(t *testing.T) {
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       nil,
+	})
+
+	_, err := svc.GetUsersOnlineStatus(context.Background(), []string{"user-1", "user-2"})
+
+	assert.Error(t, err)
+	assert.ErrorIs(t, err, ErrOnlineStoreNotConfigured)
+}
+
+func TestService_IsUserOnline_WithRedis(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       rds,
+	})
+
+	ctx := context.Background()
+	userID := "user-123"
+
+	// 初始狀態應該是離線
+	online, err := svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.False(t, online)
+
+	// 處理連線事件
+	err = svc.Online().HandleConnect(ctx, userID)
+	require.NoError(t, err)
+
+	// 現在應該在線
+	online, err = svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.True(t, online)
+
+	// 處理斷線事件
+	err = svc.Online().HandleDisconnect(ctx, userID)
+	require.NoError(t, err)
+
+	// 現在應該離線
+	online, err = svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.False(t, online)
+}
+
+func TestService_GetUsersOnlineStatus_WithRedis(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       rds,
+	})
+
+	ctx := context.Background()
+
+	// 設置一些用戶在線
+	err := svc.Online().HandleConnect(ctx, "user-1")
+	require.NoError(t, err)
+	err = svc.Online().HandleConnect(ctx, "user-3")
+	require.NoError(t, err)
+
+	// 批量獲取在線狀態
+	status, err := svc.GetUsersOnlineStatus(ctx, []string{"user-1", "user-2", "user-3"})
+	require.NoError(t, err)
+
+	assert.True(t, status["user-1"])
+	assert.False(t, status["user-2"])
+	assert.True(t, status["user-3"])
+}
+
+func TestService_Blacklist_Integration(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       rds,
+	})
+
+	ctx := context.Background()
+	userID := "user-123"
+
+	// 撤銷用戶所有 Token
+	err := svc.Blacklist().RevokeUserTokens(ctx, userID)
+	require.NoError(t, err)
+
+	// 獲取版本
+	version, err := svc.Blacklist().GetUserTokenVersion(ctx, userID)
+	require.NoError(t, err)
+	assert.Greater(t, version, int64(0))
+
+	// 檢查舊版本無效
+	valid, err := svc.Blacklist().IsTokenVersionValid(ctx, userID, version-1)
+	require.NoError(t, err)
+	assert.False(t, valid)
+
+	// 檢查當前版本有效
+	valid, err = svc.Blacklist().IsTokenVersionValid(ctx, userID, version)
+	require.NoError(t, err)
+	assert.True(t, valid)
+}
+
+func TestService_MultipleConnections(t *testing.T) {
+	rds, cleanup := setupServiceTestRedis(t)
+	defer cleanup()
+
+	svc := NewService(ServiceConfig{
+		APIURL:      "http://localhost:8000",
+		APIKey:      "test-api-key",
+		TokenSecret: "test-secret",
+		Redis:       rds,
+	})
+
+	ctx := context.Background()
+	userID := "user-123"
+
+	// 模擬多個設備連線
+	err := svc.Online().HandleConnect(ctx, userID)
+	require.NoError(t, err)
+	err = svc.Online().HandleConnect(ctx, userID)
+	require.NoError(t, err)
+	err = svc.Online().HandleConnect(ctx, userID)
+	require.NoError(t, err)
+
+	// 用戶應該在線
+	online, err := svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.True(t, online)
+
+	// 斷開一個設備
+	err = svc.Online().HandleDisconnect(ctx, userID)
+	require.NoError(t, err)
+
+	// 用戶仍然在線（還有 2 個連線）
+	online, err = svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.True(t, online)
+
+	// 斷開剩餘設備
+	err = svc.Online().HandleDisconnect(ctx, userID)
+	require.NoError(t, err)
+	err = svc.Online().HandleDisconnect(ctx, userID)
+	require.NoError(t, err)
+
+	// 用戶現在離線
+	online, err = svc.IsUserOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.False(t, online)
+}
+

pkg/library/centrifugo/client.go

@@ -0,0 +1,519 @@
+package centrifugo
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"time"
+)
+
+// Client Centrifugo 客戶端
+type Client struct {
+	apiURL string
+	apiKey string
+	client *http.Client
+}
+
+// ClientConfig 客戶端配置
+type ClientConfig struct {
+	// APIURL Centrifugo API 地址（必填）
+	APIURL string
+	// APIKey API 密鑰（必填）
+	APIKey string
+
+	// Timeout 整體請求超時時間（預設 10 秒）
+	Timeout time.Duration
+	// MaxIdleConns 最大閒置連線數（預設 100）
+	MaxIdleConns int
+	// MaxIdleConnsPerHost 每個 host 最大閒置連線數（預設 20，適合高併發）
+	MaxIdleConnsPerHost int
+	// IdleConnTimeout 閒置連線超時時間（預設 90 秒）
+	IdleConnTimeout time.Duration
+	// DialTimeout 建立連線超時時間（預設 5 秒）
+	DialTimeout time.Duration
+	// TLSHandshakeTimeout TLS 握手超時時間（預設 5 秒）
+	TLSHandshakeTimeout time.Duration
+	// ResponseHeaderTimeout 等待響應頭超時時間（預設 10 秒）
+	ResponseHeaderTimeout time.Duration
+}
+
+// DefaultConfig 返回預設配置
+func DefaultConfig(apiURL, apiKey string) ClientConfig {
+	return ClientConfig{
+		APIURL:                apiURL,
+		APIKey:                apiKey,
+		Timeout:               10 * time.Second,
+		MaxIdleConns:          100,
+		MaxIdleConnsPerHost:   20, // 提高以支援高併發
+		IdleConnTimeout:       90 * time.Second,
+		DialTimeout:           5 * time.Second,
+		TLSHandshakeTimeout:   5 * time.Second,
+		ResponseHeaderTimeout: 10 * time.Second,
+	}
+}
+
+// HighPerformanceConfig 返回高效能配置（適合高併發場景）
+func HighPerformanceConfig(apiURL, apiKey string) ClientConfig {
+	return ClientConfig{
+		APIURL:                apiURL,
+		APIKey:                apiKey,
+		Timeout:               5 * time.Second,  // 更短的超時
+		MaxIdleConns:          200,              // 更多閒置連線
+		MaxIdleConnsPerHost:   50,               // 更多每 host 連線
+		IdleConnTimeout:       120 * time.Second,
+		DialTimeout:           3 * time.Second,
+		TLSHandshakeTimeout:   3 * time.Second,
+		ResponseHeaderTimeout: 5 * time.Second,
+	}
+}
+
+// NewClient 創建新的 Centrifugo 客戶端（使用預設配置）
+func NewClient(apiURL, apiKey string) *Client {
+	return NewClientWithConfig(DefaultConfig(apiURL, apiKey))
+}
+
+// NewClientWithConfig 創建使用自定義配置的 Centrifugo 客戶端
+func NewClientWithConfig(config ClientConfig) *Client {
+	// 設定預設值
+	if config.Timeout == 0 {
+		config.Timeout = 10 * time.Second
+	}
+	if config.MaxIdleConns == 0 {
+		config.MaxIdleConns = 100
+	}
+	if config.MaxIdleConnsPerHost == 0 {
+		config.MaxIdleConnsPerHost = 20
+	}
+	if config.IdleConnTimeout == 0 {
+		config.IdleConnTimeout = 90 * time.Second
+	}
+	if config.DialTimeout == 0 {
+		config.DialTimeout = 5 * time.Second
+	}
+	if config.TLSHandshakeTimeout == 0 {
+		config.TLSHandshakeTimeout = 5 * time.Second
+	}
+	if config.ResponseHeaderTimeout == 0 {
+		config.ResponseHeaderTimeout = 10 * time.Second
+	}
+
+	transport := &http.Transport{
+		DialContext: (&net.Dialer{
+			Timeout:   config.DialTimeout,
+			KeepAlive: 30 * time.Second, // TCP keep-alive
+		}).DialContext,
+		MaxIdleConns:          config.MaxIdleConns,
+		MaxIdleConnsPerHost:   config.MaxIdleConnsPerHost,
+		IdleConnTimeout:       config.IdleConnTimeout,
+		TLSHandshakeTimeout:   config.TLSHandshakeTimeout,
+		ResponseHeaderTimeout: config.ResponseHeaderTimeout,
+		ForceAttemptHTTP2:     true, // 嘗試使用 HTTP/2
+	}
+
+	return &Client{
+		apiURL: config.APIURL,
+		apiKey: config.APIKey,
+		client: &http.Client{
+			Timeout:   config.Timeout,
+			Transport: transport,
+		},
+	}
+}
+
+// NewClientWithHTTP 創建使用自定義 HTTP 客戶端的 Centrifugo 客戶端
+func NewClientWithHTTP(apiURL, apiKey string, httpClient *http.Client) *Client {
+	return &Client{
+		apiURL: apiURL,
+		apiKey: apiKey,
+		client: httpClient,
+	}
+}
+
+// ==================== Request/Response 結構 ====================
+
+// PublishRequest 發布請求
+type PublishRequest struct {
+	Channel string      `json:"channel"`
+	Data    interface{} `json:"data"`
+}
+
+// BroadcastRequest 批量發布請求
+type BroadcastRequest struct {
+	Channels []string    `json:"channels"`
+	Data     interface{} `json:"data"`
+}
+
+// SubscribeRequest 訂閱請求
+type SubscribeRequest struct {
+	User    string `json:"user"`
+	Channel string `json:"channel"`
+}
+
+// UnsubscribeRequest 取消訂閱請求
+type UnsubscribeRequest struct {
+	User    string `json:"user"`
+	Channel string `json:"channel"`
+}
+
+// DisconnectRequest 斷開連線請求
+type DisconnectRequest struct {
+	User string `json:"user"`
+}
+
+// DisconnectWithCodeRequest 帶代碼的斷開連線請求
+type DisconnectWithCodeRequest struct {
+	User       string         `json:"user"`
+	Disconnect DisconnectInfo `json:"disconnect,omitempty"`
+}
+
+// DisconnectInfo 斷開連線資訊
+type DisconnectInfo struct {
+	Code   uint32 `json:"code"`
+	Reason string `json:"reason"`
+}
+
+// PresenceRequest 在線狀態請求
+type PresenceRequest struct {
+	Channel string `json:"channel"`
+}
+
+// PresenceStatsRequest 在線統計請求
+type PresenceStatsRequest struct {
+	Channel string `json:"channel"`
+}
+
+// HistoryRequest 歷史訊息請求
+type HistoryRequest struct {
+	Channel string `json:"channel"`
+	Limit   int    `json:"limit,omitempty"`
+	Reverse bool   `json:"reverse,omitempty"`
+}
+
+// ChannelsRequest 頻道列表請求
+type ChannelsRequest struct {
+	Pattern string `json:"pattern,omitempty"`
+}
+
+// InfoRequest 伺服器資訊請求
+type InfoRequest struct{}
+
+// APIResponse Centrifugo API 通用響應
+type APIResponse struct {
+	Error  *APIError   `json:"error,omitempty"`
+	Result interface{} `json:"result,omitempty"`
+}
+
+// APIError Centrifugo API 錯誤
+type APIError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+func (e *APIError) Error() string {
+	return fmt.Sprintf("centrifugo error %d: %s", e.Code, e.Message)
+}
+
+// PublishResult 發布結果
+type PublishResult struct {
+	Offset uint64 `json:"offset,omitempty"`
+	Epoch  string `json:"epoch,omitempty"`
+}
+
+// PresenceResult 在線狀態結果
+type PresenceResult struct {
+	Presence map[string]ClientInfo `json:"presence"`
+}
+
+// ClientInfo 客戶端資訊
+type ClientInfo struct {
+	User     string          `json:"user"`
+	Client   string          `json:"client"`
+	ConnInfo json.RawMessage `json:"conn_info,omitempty"`
+	ChanInfo json.RawMessage `json:"chan_info,omitempty"`
+}
+
+// PresenceStatsResult 在線統計結果
+type PresenceStatsResult struct {
+	NumClients int `json:"num_clients"`
+	NumUsers   int `json:"num_users"`
+}
+
+// HistoryResult 歷史訊息結果
+type HistoryResult struct {
+	Publications []Publication `json:"publications"`
+	Offset       uint64        `json:"offset,omitempty"`
+	Epoch        string        `json:"epoch,omitempty"`
+}
+
+// Publication 發布的訊息
+type Publication struct {
+	Offset uint64          `json:"offset,omitempty"`
+	Data   json.RawMessage `json:"data"`
+	Info   *ClientInfo     `json:"info,omitempty"`
+}
+
+// ChannelsResult 頻道列表結果
+type ChannelsResult struct {
+	Channels map[string]ChannelInfo `json:"channels"`
+}
+
+// ChannelInfo 頻道資訊
+type ChannelInfo struct {
+	NumClients int `json:"num_clients"`
+}
+
+// InfoResult 伺服器資訊結果
+type InfoResult struct {
+	Nodes []NodeInfo `json:"nodes"`
+}
+
+// NodeInfo 節點資訊
+type NodeInfo struct {
+	UID         string `json:"uid"`
+	Name        string `json:"name"`
+	Version     string `json:"version"`
+	NumClients  int    `json:"num_clients"`
+	NumUsers    int    `json:"num_users"`
+	NumChannels int    `json:"num_channels"`
+	Uptime      int    `json:"uptime"`
+}
+
+// ==================== 發布相關方法 ====================
+
+// Publish 發布訊息到指定頻道
+func (c *Client) Publish(ctx context.Context, channel string, data []byte) (*PublishResult, error) {
+	req := PublishRequest{
+		Channel: channel,
+		Data:    json.RawMessage(data),
+	}
+	return c.publish(ctx, req)
+}
+
+// PublishJSON 發布 JSON 訊息到指定頻道
+func (c *Client) PublishJSON(ctx context.Context, channel string, data interface{}) (*PublishResult, error) {
+	req := PublishRequest{
+		Channel: channel,
+		Data:    data,
+	}
+	return c.publish(ctx, req)
+}
+
+func (c *Client) publish(ctx context.Context, req PublishRequest) (*PublishResult, error) {
+	var result PublishResult
+	if err := c.callAPI(ctx, "publish", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// Broadcast 批量發布訊息到多個頻道
+func (c *Client) Broadcast(ctx context.Context, channels []string, data []byte) error {
+	req := BroadcastRequest{
+		Channels: channels,
+		Data:     json.RawMessage(data),
+	}
+	return c.callAPI(ctx, "broadcast", req, nil)
+}
+
+// BroadcastJSON 批量發布 JSON 訊息到多個頻道
+func (c *Client) BroadcastJSON(ctx context.Context, channels []string, data interface{}) error {
+	req := BroadcastRequest{
+		Channels: channels,
+		Data:     data,
+	}
+	return c.callAPI(ctx, "broadcast", req, nil)
+}
+
+// ==================== 訂閱管理方法 ====================
+
+// Subscribe 訂閱用戶到頻道
+func (c *Client) Subscribe(ctx context.Context, user, channel string) error {
+	req := SubscribeRequest{
+		User:    user,
+		Channel: channel,
+	}
+	return c.callAPI(ctx, "subscribe", req, nil)
+}
+
+// Unsubscribe 取消用戶訂閱
+func (c *Client) Unsubscribe(ctx context.Context, user, channel string) error {
+	req := UnsubscribeRequest{
+		User:    user,
+		Channel: channel,
+	}
+	return c.callAPI(ctx, "unsubscribe", req, nil)
+}
+
+// Disconnect 強制斷開用戶連線
+func (c *Client) Disconnect(ctx context.Context, user string) error {
+	req := DisconnectRequest{
+		User: user,
+	}
+	return c.callAPI(ctx, "disconnect", req, nil)
+}
+
+// DisconnectWithCode 強制斷開用戶連線（帶斷開代碼和原因）
+func (c *Client) DisconnectWithCode(ctx context.Context, user string, code uint32, reason string) error {
+	req := DisconnectWithCodeRequest{
+		User: user,
+		Disconnect: DisconnectInfo{
+			Code:   code,
+			Reason: reason,
+		},
+	}
+	return c.callAPI(ctx, "disconnect", req, nil)
+}
+
+
+// ==================== 在線狀態方法 ====================
+
+// Presence 獲取頻道在線用戶
+func (c *Client) Presence(ctx context.Context, channel string) (*PresenceResult, error) {
+	req := PresenceRequest{
+		Channel: channel,
+	}
+	var result PresenceResult
+	if err := c.callAPI(ctx, "presence", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// PresenceStats 獲取頻道在線統計
+func (c *Client) PresenceStats(ctx context.Context, channel string) (*PresenceStatsResult, error) {
+	req := PresenceStatsRequest{
+		Channel: channel,
+	}
+	var result PresenceStatsResult
+	if err := c.callAPI(ctx, "presence_stats", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// ==================== 歷史訊息方法 ====================
+
+// History 獲取頻道歷史訊息
+func (c *Client) History(ctx context.Context, channel string, limit int) (*HistoryResult, error) {
+	req := HistoryRequest{
+		Channel: channel,
+		Limit:   limit,
+	}
+	var result HistoryResult
+	if err := c.callAPI(ctx, "history", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// HistoryReverse 獲取頻道歷史訊息（倒序）
+func (c *Client) HistoryReverse(ctx context.Context, channel string, limit int) (*HistoryResult, error) {
+	req := HistoryRequest{
+		Channel: channel,
+		Limit:   limit,
+		Reverse: true,
+	}
+	var result HistoryResult
+	if err := c.callAPI(ctx, "history", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// ==================== 頻道管理方法 ====================
+
+// Channels 獲取所有活躍頻道
+func (c *Client) Channels(ctx context.Context) (*ChannelsResult, error) {
+	req := ChannelsRequest{}
+	var result ChannelsResult
+	if err := c.callAPI(ctx, "channels", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// ChannelsWithPattern 獲取匹配模式的活躍頻道
+func (c *Client) ChannelsWithPattern(ctx context.Context, pattern string) (*ChannelsResult, error) {
+	req := ChannelsRequest{
+		Pattern: pattern,
+	}
+	var result ChannelsResult
+	if err := c.callAPI(ctx, "channels", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// ==================== 伺服器狀態方法 ====================
+
+// Info 獲取伺服器狀態資訊
+func (c *Client) Info(ctx context.Context) (*InfoResult, error) {
+	req := InfoRequest{}
+	var result InfoResult
+	if err := c.callAPI(ctx, "info", req, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// Ping 檢查伺服器是否健康
+func (c *Client) Ping(ctx context.Context) error {
+	_, err := c.Info(ctx)
+	return err
+}
+
+// ==================== 內部方法 ====================
+
+// callAPI 調用 Centrifugo API
+func (c *Client) callAPI(ctx context.Context, method string, params interface{}, result interface{}) error {
+	body, err := json.Marshal(params)
+	if err != nil {
+		return fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	url := fmt.Sprintf("%s/api/%s", c.apiURL, method)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	httpReq.Header.Set("Content-Type", "application/json")
+	if c.apiKey != "" {
+		httpReq.Header.Set("Authorization", "apikey "+c.apiKey)
+	}
+
+	resp, err := c.client.Do(httpReq)
+	if err != nil {
+		return fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("centrifugo returned status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	// 解析響應
+	var apiResp APIResponse
+	if result != nil {
+		apiResp.Result = result
+	}
+
+	if err := json.Unmarshal(respBody, &apiResp); err != nil {
+		return fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+
+	if apiResp.Error != nil {
+		return apiResp.Error
+	}
+
+	return nil
+}

pkg/library/centrifugo/online.go

@@ -0,0 +1,175 @@
+package centrifugo
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// OnlineStatus 在線狀態
+type OnlineStatus struct {
+	UserID     string    `json:"user_id"`
+	IsOnline   bool      `json:"is_online"`
+	LastSeenAt time.Time `json:"last_seen_at,omitempty"`
+	Clients    int       `json:"clients,omitempty"` // 連線數（可能多個設備）
+}
+
+// OnlineStore 在線狀態存儲介面
+// 可以用 Redis、Memory 或其他存儲實作
+type OnlineStore interface {
+	// SetOnline 設置用戶在線
+	SetOnline(ctx context.Context, userID string, ttl time.Duration) error
+	// SetOffline 設置用戶離線
+	SetOffline(ctx context.Context, userID string) error
+	// IsOnline 檢查用戶是否在線
+	IsOnline(ctx context.Context, userID string) (bool, error)
+	// GetOnlineUsers 獲取在線用戶列表
+	GetOnlineUsers(ctx context.Context, userIDs []string) (map[string]bool, error)
+	// IncrClient 增加用戶連線數
+	IncrClient(ctx context.Context, userID string) (int64, error)
+	// DecrClient 減少用戶連線數
+	DecrClient(ctx context.Context, userID string) (int64, error)
+}
+
+// OnlineManager 在線狀態管理器
+// 結合 Redis 存儲和 Centrifugo Presence API 提供在線狀態追蹤
+type OnlineManager struct {
+	client *Client
+	store  OnlineStore
+	ttl    time.Duration
+}
+
+// NewOnlineManager 創建在線狀態管理器
+// store 可以為 nil，此時只使用 Centrifugo Presence API
+func NewOnlineManager(client *Client, store OnlineStore) *OnlineManager {
+	return &OnlineManager{
+		client: client,
+		store:  store,
+		ttl:    5 * time.Minute, // 預設 5 分鐘過期
+	}
+}
+
+// NewOnlineManagerWithTTL 創建帶 TTL 的在線狀態管理器
+func NewOnlineManagerWithTTL(client *Client, store OnlineStore, ttl time.Duration) *OnlineManager {
+	return &OnlineManager{
+		client: client,
+		store:  store,
+		ttl:    ttl,
+	}
+}
+
+// ==================== 連線事件處理 ====================
+
+// HandleConnect 處理用戶連線事件（用於 Centrifugo Connect Proxy）
+func (m *OnlineManager) HandleConnect(ctx context.Context, userID string) error {
+	if m.store == nil {
+		return nil
+	}
+
+	// 增加連線數
+	count, err := m.store.IncrClient(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to incr client: %w", err)
+	}
+
+	// 如果是第一個連線，設置在線狀態
+	if count == 1 {
+		if err := m.store.SetOnline(ctx, userID, m.ttl); err != nil {
+			return fmt.Errorf("failed to set online: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// HandleDisconnect 處理用戶斷線事件（用於 Centrifugo Disconnect Proxy）
+func (m *OnlineManager) HandleDisconnect(ctx context.Context, userID string) error {
+	if m.store == nil {
+		return nil
+	}
+
+	// 減少連線數
+	count, err := m.store.DecrClient(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to decr client: %w", err)
+	}
+
+	// 如果沒有連線了，設置離線狀態
+	if count <= 0 {
+		if err := m.store.SetOffline(ctx, userID); err != nil {
+			return fmt.Errorf("failed to set offline: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// ==================== 在線狀態查詢 ====================
+
+// IsUserOnline 檢查用戶是否在線（使用 Store）
+func (m *OnlineManager) IsUserOnline(ctx context.Context, userID string) (bool, error) {
+	if m.store == nil {
+		return false, ErrOnlineStoreNotConfigured
+	}
+	return m.store.IsOnline(ctx, userID)
+}
+
+// GetUsersOnlineStatus 批量獲取用戶在線狀態
+func (m *OnlineManager) GetUsersOnlineStatus(ctx context.Context, userIDs []string) (map[string]bool, error) {
+	if m.store == nil {
+		return nil, ErrOnlineStoreNotConfigured
+	}
+	return m.store.GetOnlineUsers(ctx, userIDs)
+}
+
+// RefreshOnline 刷新用戶在線狀態（用於心跳）
+func (m *OnlineManager) RefreshOnline(ctx context.Context, userID string) error {
+	if m.store == nil {
+		return nil
+	}
+	return m.store.SetOnline(ctx, userID, m.ttl)
+}
+
+// ==================== Centrifugo Presence API ====================
+
+// IsUserInChannel 檢查用戶是否在指定頻道中（使用 Centrifugo Presence）
+func (m *OnlineManager) IsUserInChannel(ctx context.Context, userID, channel string) (bool, error) {
+	presence, err := m.client.Presence(ctx, channel)
+	if err != nil {
+		return false, err
+	}
+
+	for _, info := range presence.Presence {
+		if info.User == userID {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+// GetChannelOnlineUsers 獲取頻道中的在線用戶（使用 Centrifugo Presence）
+func (m *OnlineManager) GetChannelOnlineUsers(ctx context.Context, channel string) ([]string, error) {
+	presence, err := m.client.Presence(ctx, channel)
+	if err != nil {
+		return nil, err
+	}
+
+	// 去重（一個用戶可能有多個連線）
+	userMap := make(map[string]bool)
+	for _, info := range presence.Presence {
+		userMap[info.User] = true
+	}
+
+	users := make([]string, 0, len(userMap))
+	for userID := range userMap {
+		users = append(users, userID)
+	}
+
+	return users, nil
+}
+
+// GetChannelStats 獲取頻道在線統計
+func (m *OnlineManager) GetChannelStats(ctx context.Context, channel string) (*PresenceStatsResult, error) {
+	return m.client.PresenceStats(ctx, channel)
+}

pkg/library/centrifugo/online_redis.go

@@ -0,0 +1,141 @@
+package centrifugo
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+// RedisOnlineStore 使用 Redis 實作的在線狀態存儲
+type RedisOnlineStore struct {
+	client    *redis.Redis
+	keyPrefix string
+}
+
+// NewRedisOnlineStore 創建 Redis 在線狀態存儲
+func NewRedisOnlineStore(client *redis.Redis) *RedisOnlineStore {
+	return &RedisOnlineStore{
+		client:    client,
+		keyPrefix: "online:",
+	}
+}
+
+// NewRedisOnlineStoreWithPrefix 創建帶自定義前綴的 Redis 在線狀態存儲
+func NewRedisOnlineStoreWithPrefix(client *redis.Redis, prefix string) *RedisOnlineStore {
+	return &RedisOnlineStore{
+		client:    client,
+		keyPrefix: prefix,
+	}
+}
+
+// key 生成 Redis key
+func (s *RedisOnlineStore) key(userID string) string {
+	return s.keyPrefix + userID
+}
+
+// clientCountKey 生成連線數 key
+func (s *RedisOnlineStore) clientCountKey(userID string) string {
+	return s.keyPrefix + "clients:" + userID
+}
+
+// SetOnline 設置用戶在線
+func (s *RedisOnlineStore) SetOnline(ctx context.Context, userID string, ttl time.Duration) error {
+	return s.client.SetexCtx(ctx, s.key(userID), fmt.Sprintf("%d", time.Now().Unix()), int(ttl.Seconds()))
+}
+
+// SetOffline 設置用戶離線
+func (s *RedisOnlineStore) SetOffline(ctx context.Context, userID string) error {
+	// 刪除在線狀態
+	_, err := s.client.DelCtx(ctx, s.key(userID))
+	if err != nil {
+		return err
+	}
+	// 刪除連線數
+	_, err = s.client.DelCtx(ctx, s.clientCountKey(userID))
+	return err
+}
+
+// IsOnline 檢查用戶是否在線
+func (s *RedisOnlineStore) IsOnline(ctx context.Context, userID string) (bool, error) {
+	return s.client.ExistsCtx(ctx, s.key(userID))
+}
+
+// GetOnlineUsers 批量獲取在線用戶狀態
+func (s *RedisOnlineStore) GetOnlineUsers(ctx context.Context, userIDs []string) (map[string]bool, error) {
+	if len(userIDs) == 0 {
+		return make(map[string]bool), nil
+	}
+
+	result := make(map[string]bool, len(userIDs))
+	for _, userID := range userIDs {
+		exists, err := s.client.ExistsCtx(ctx, s.key(userID))
+		if err != nil {
+			return nil, fmt.Errorf("failed to check online status for %s: %w", userID, err)
+		}
+		result[userID] = exists
+	}
+
+	return result, nil
+}
+
+// IncrClient 增加用戶連線數
+func (s *RedisOnlineStore) IncrClient(ctx context.Context, userID string) (int64, error) {
+	count, err := s.client.IncrCtx(ctx, s.clientCountKey(userID))
+	if err != nil {
+		return 0, err
+	}
+	return int64(count), nil
+}
+
+// DecrClient 減少用戶連線數
+func (s *RedisOnlineStore) DecrClient(ctx context.Context, userID string) (int64, error) {
+	count, err := s.client.DecrCtx(ctx, s.clientCountKey(userID))
+	if err != nil {
+		return 0, err
+	}
+
+	// 確保不會變成負數
+	if count < 0 {
+		_ = s.client.SetCtx(ctx, s.clientCountKey(userID), "0")
+		return 0, nil
+	}
+
+	return int64(count), nil
+}
+
+// GetClientCount 獲取用戶連線數
+func (s *RedisOnlineStore) GetClientCount(ctx context.Context, userID string) (int64, error) {
+	val, err := s.client.GetCtx(ctx, s.clientCountKey(userID))
+	if err != nil {
+		return 0, err
+	}
+	if val == "" {
+		return 0, nil
+	}
+	return strconv.ParseInt(val, 10, 64)
+}
+
+// GetAllOnlineUserIDs 獲取所有在線用戶 ID
+// 注意：此方法使用 KEYS 命令，在大規模生產環境中可能有性能問題
+// 建議在需要時使用 Centrifugo Presence API 替代
+func (s *RedisOnlineStore) GetAllOnlineUserIDs(ctx context.Context) ([]string, error) {
+	// 使用 KEYS 查找所有在線用戶（排除 clients: 開頭的 key）
+	pattern := s.keyPrefix + "[^c]*"
+	keys, err := s.client.KeysCtx(ctx, pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	userIDs := make([]string, 0, len(keys))
+	prefixLen := len(s.keyPrefix)
+	for _, key := range keys {
+		if len(key) > prefixLen {
+			userIDs = append(userIDs, key[prefixLen:])
+		}
+	}
+
+	return userIDs, nil
+}

pkg/library/centrifugo/online_redis_test.go

@@ -0,0 +1,272 @@
+package centrifugo
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis/v2"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+func setupOnlineTestRedis(t *testing.T) (*redis.Redis, func()) {
+	mr, err := miniredis.Run()
+	require.NoError(t, err)
+
+	rds, err := redis.NewRedis(redis.RedisConf{
+		Host: mr.Addr(),
+		Type: "node",
+	})
+	require.NoError(t, err)
+
+	return rds, func() {
+		mr.Close()
+	}
+}
+
+func TestNewRedisOnlineStore(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+
+	assert.NotNil(t, store)
+	assert.Equal(t, "online:", store.keyPrefix)
+}
+
+func TestNewRedisOnlineStoreWithPrefix(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStoreWithPrefix(rds, "custom:online:")
+
+	assert.NotNil(t, store)
+	assert.Equal(t, "custom:online:", store.keyPrefix)
+}
+
+func TestSetOnline(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+	ttl := 5 * time.Minute
+
+	// 設置在線
+	err := store.SetOnline(ctx, userID, ttl)
+	require.NoError(t, err)
+
+	// 檢查是否在線
+	online, err := store.IsOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.True(t, online)
+}
+
+func TestSetOffline(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 先設置在線
+	err := store.SetOnline(ctx, userID, 5*time.Minute)
+	require.NoError(t, err)
+
+	// 設置離線
+	err = store.SetOffline(ctx, userID)
+	require.NoError(t, err)
+
+	// 檢查是否離線
+	online, err := store.IsOnline(ctx, userID)
+	require.NoError(t, err)
+	assert.False(t, online)
+}
+
+func TestIsOnline_NotOnline(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	// 未設置在線的用戶應該返回 false
+	online, err := store.IsOnline(ctx, "non-existent-user")
+	require.NoError(t, err)
+	assert.False(t, online)
+}
+
+func TestGetOnlineUsers(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	// 設置一些用戶在線
+	err := store.SetOnline(ctx, "user-1", 5*time.Minute)
+	require.NoError(t, err)
+	err = store.SetOnline(ctx, "user-3", 5*time.Minute)
+	require.NoError(t, err)
+
+	// 批量獲取在線狀態
+	userIDs := []string{"user-1", "user-2", "user-3"}
+	status, err := store.GetOnlineUsers(ctx, userIDs)
+	require.NoError(t, err)
+
+	assert.True(t, status["user-1"])
+	assert.False(t, status["user-2"])
+	assert.True(t, status["user-3"])
+}
+
+func TestGetOnlineUsers_Empty(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	// 空列表應該返回空 map
+	status, err := store.GetOnlineUsers(ctx, []string{})
+	require.NoError(t, err)
+	assert.Empty(t, status)
+}
+
+func TestIncrClient(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 第一次增加
+	count, err := store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), count)
+
+	// 第二次增加
+	count, err = store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), count)
+
+	// 獲取連線數
+	count, err = store.GetClientCount(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), count)
+}
+
+func TestDecrClient(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 先增加到 2
+	_, err := store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+	_, err = store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+
+	// 減少一次
+	count, err := store.DecrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), count)
+
+	// 再減少一次
+	count, err = store.DecrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), count)
+}
+
+func TestDecrClient_NegativeProtection(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 直接減少（沒有先增加）
+	count, err := store.DecrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), count) // 應該被保護為 0
+
+	// 再次減少
+	count, err = store.DecrClient(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), count) // 仍然是 0
+}
+
+func TestGetClientCount_NoClient(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	// 未設置連線數的用戶應該返回 0
+	count, err := store.GetClientCount(ctx, "non-existent-user")
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), count)
+}
+
+func TestSetOffline_ClearsClientCount(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+	ctx := context.Background()
+
+	userID := "user-123"
+
+	// 設置在線和連線數
+	err := store.SetOnline(ctx, userID, 5*time.Minute)
+	require.NoError(t, err)
+	_, err = store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+	_, err = store.IncrClient(ctx, userID)
+	require.NoError(t, err)
+
+	// 設置離線
+	err = store.SetOffline(ctx, userID)
+	require.NoError(t, err)
+
+	// 連線數也應該被清除
+	count, err := store.GetClientCount(ctx, userID)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), count)
+}
+
+func TestKeyGeneration_OnlineStore(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStoreWithPrefix(rds, "test:")
+
+	// 測試 key 生成
+	assert.Equal(t, "test:user-123", store.key("user-123"))
+	assert.Equal(t, "test:clients:user-456", store.clientCountKey("user-456"))
+}
+
+func TestOnlineStore_ImplementsInterface(t *testing.T) {
+	rds, cleanup := setupOnlineTestRedis(t)
+	defer cleanup()
+
+	store := NewRedisOnlineStore(rds)
+
+	// 確保 RedisOnlineStore 實現了 OnlineStore 介面
+	var _ OnlineStore = store
+}
+

pkg/library/centrifugo/token.go

@@ -0,0 +1,203 @@
+package centrifugo
+
+import (
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/google/uuid"
+)
+
+// TokenConfig JWT Token 配置
+type TokenConfig struct {
+	// Secret 用於簽名的密鑰（與 Centrifugo 配置的 token_hmac_secret_key 一致）
+	Secret string
+	// ExpireIn Token 過期時間（預設 1 小時）
+	ExpireIn time.Duration
+}
+
+// TokenGenerator JWT Token 生成器
+type TokenGenerator struct {
+	config TokenConfig
+}
+
+// NewTokenGenerator 創建新的 Token 生成器
+func NewTokenGenerator(secret string) *TokenGenerator {
+	return &TokenGenerator{
+		config: TokenConfig{
+			Secret:   secret,
+			ExpireIn: time.Hour,
+		},
+	}
+}
+
+// NewTokenGeneratorWithConfig 創建使用自定義配置的 Token 生成器
+func NewTokenGeneratorWithConfig(config TokenConfig) *TokenGenerator {
+	if config.ExpireIn == 0 {
+		config.ExpireIn = time.Hour
+	}
+	return &TokenGenerator{
+		config: config,
+	}
+}
+
+// ConnectionClaims 連線 Token 的 Claims
+type ConnectionClaims struct {
+	jwt.RegisteredClaims
+	// Sub 用戶 ID（必填）
+	Sub string `json:"sub"`
+	// Info 用戶資訊（可選，會在 presence 中顯示）
+	Info map[string]interface{} `json:"info,omitempty"`
+	// Channels 自動訂閱的頻道列表（可選）
+	Channels []string `json:"channels,omitempty"`
+	// TokenVersion Token 版本（用於批量撤銷）
+	TokenVersion int64 `json:"tv,omitempty"`
+}
+
+// SubscriptionClaims 訂閱 Token 的 Claims（用於私有頻道）
+type SubscriptionClaims struct {
+	jwt.RegisteredClaims
+	// Sub 用戶 ID（必填）
+	Sub string `json:"sub"`
+	// Channel 頻道名稱（必填）
+	Channel string `json:"channel"`
+	// Info 頻道特定的用戶資訊（可選）
+	Info map[string]interface{} `json:"info,omitempty"`
+	// TokenVersion Token 版本（用於批量撤銷）
+	TokenVersion int64 `json:"tv,omitempty"`
+}
+
+// ConnectionTokenOptions 連線 Token 選項
+type ConnectionTokenOptions struct {
+	// UserID 用戶 ID（必填）
+	UserID string
+	// Info 用戶資訊（可選）
+	Info map[string]interface{}
+	// Channels 自動訂閱的頻道列表（可選）
+	Channels []string
+	// ExpireAt 自定義過期時間（可選，為空則使用預設）
+	ExpireAt *time.Time
+	// TokenVersion Token 版本（可選，用於黑名單機制）
+	TokenVersion int64
+}
+
+// SubscriptionTokenOptions 訂閱 Token 選項
+type SubscriptionTokenOptions struct {
+	// UserID 用戶 ID（必填）
+	UserID string
+	// Channel 頻道名稱（必填）
+	Channel string
+	// Info 頻道特定的用戶資訊（可選）
+	Info map[string]interface{}
+	// ExpireAt 自定義過期時間（可選，為空則使用預設）
+	ExpireAt *time.Time
+	// TokenVersion Token 版本（可選，用於黑名單機制）
+	TokenVersion int64
+}
+
+// TokenResult 生成 Token 的結果
+type TokenResult struct {
+	Token     string    // JWT Token 字串
+	JTI       string    // JWT ID（用於撤銷單一 Token）
+	ExpiresAt time.Time // 過期時間
+}
+
+// GenerateConnectionToken 生成連線 Token
+// 用於前端建立 WebSocket 連線時的身份驗證
+func (g *TokenGenerator) GenerateConnectionToken(opts ConnectionTokenOptions) (string, error) {
+	result, err := g.GenerateConnectionTokenWithJTI(opts)
+	if err != nil {
+		return "", err
+	}
+	return result.Token, nil
+}
+
+// GenerateConnectionTokenWithJTI 生成連線 Token 並返回 JTI
+// 用於需要支援單一 Token 撤銷的場景
+func (g *TokenGenerator) GenerateConnectionTokenWithJTI(opts ConnectionTokenOptions) (*TokenResult, error) {
+	now := time.Now()
+	expireAt := now.Add(g.config.ExpireIn)
+	if opts.ExpireAt != nil {
+		expireAt = *opts.ExpireAt
+	}
+
+	// 生成唯一的 JTI
+	jti := uuid.New().String()
+
+	// 如果沒有指定 TokenVersion，使用當前時間戳
+	tokenVersion := opts.TokenVersion
+	if tokenVersion == 0 {
+		tokenVersion = now.UnixNano()
+	}
+
+	claims := ConnectionClaims{
+		RegisteredClaims: jwt.RegisteredClaims{
+			ID:        jti,
+			Subject:   opts.UserID,
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(expireAt),
+		},
+		Sub:          opts.UserID,
+		Info:         opts.Info,
+		Channels:     opts.Channels,
+		TokenVersion: tokenVersion,
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenStr, err := token.SignedString([]byte(g.config.Secret))
+	if err != nil {
+		return nil, err
+	}
+
+	return &TokenResult{
+		Token:     tokenStr,
+		JTI:       jti,
+		ExpiresAt: expireAt,
+	}, nil
+}
+
+// GenerateSubscriptionToken 生成訂閱 Token
+// 用於訂閱私有頻道時的身份驗證
+func (g *TokenGenerator) GenerateSubscriptionToken(opts SubscriptionTokenOptions) (string, error) {
+	now := time.Now()
+	expireAt := now.Add(g.config.ExpireIn)
+	if opts.ExpireAt != nil {
+		expireAt = *opts.ExpireAt
+	}
+
+	claims := SubscriptionClaims{
+		RegisteredClaims: jwt.RegisteredClaims{
+			Subject:   opts.UserID,
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(expireAt),
+		},
+		Sub:     opts.UserID,
+		Channel: opts.Channel,
+		Info:    opts.Info,
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString([]byte(g.config.Secret))
+}
+
+// GenerateAnonymousToken 生成匿名連線 Token
+// 用於允許匿名用戶連線（但仍需要驗證）
+func (g *TokenGenerator) GenerateAnonymousToken() (string, error) {
+	return g.GenerateConnectionToken(ConnectionTokenOptions{
+		UserID: "", // 空的 UserID 表示匿名用戶
+	})
+}
+
+// QuickConnectionToken 快速生成連線 Token（只需用戶 ID）
+func (g *TokenGenerator) QuickConnectionToken(userID string) (string, error) {
+	return g.GenerateConnectionToken(ConnectionTokenOptions{
+		UserID: userID,
+	})
+}
+
+// QuickSubscriptionToken 快速生成訂閱 Token（只需用戶 ID 和頻道）
+func (g *TokenGenerator) QuickSubscriptionToken(userID, channel string) (string, error) {
+	return g.GenerateSubscriptionToken(SubscriptionTokenOptions{
+		UserID:  userID,
+		Channel: channel,
+	})
+}

pkg/library/centrifugo/token_test.go

@@ -0,0 +1,263 @@
+package centrifugo
+
+import (
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewTokenGenerator(t *testing.T) {
+	secret := "test-secret"
+	gen := NewTokenGenerator(secret)
+
+	assert.NotNil(t, gen)
+	assert.Equal(t, secret, gen.config.Secret)
+	assert.Equal(t, time.Hour, gen.config.ExpireIn)
+}
+
+func TestNewTokenGeneratorWithConfig(t *testing.T) {
+	config := TokenConfig{
+		Secret:   "custom-secret",
+		ExpireIn: 24 * time.Hour,
+	}
+	gen := NewTokenGeneratorWithConfig(config)
+
+	assert.NotNil(t, gen)
+	assert.Equal(t, config.Secret, gen.config.Secret)
+	assert.Equal(t, config.ExpireIn, gen.config.ExpireIn)
+}
+
+func TestNewTokenGeneratorWithConfig_DefaultExpire(t *testing.T) {
+	config := TokenConfig{
+		Secret:   "test-secret",
+		ExpireIn: 0, // 應該使用預設值
+	}
+	gen := NewTokenGeneratorWithConfig(config)
+
+	assert.Equal(t, time.Hour, gen.config.ExpireIn)
+}
+
+func TestQuickConnectionToken(t *testing.T) {
+	gen := NewTokenGenerator("test-secret")
+	userID := "user-123"
+
+	token, err := gen.QuickConnectionToken(userID)
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+
+	// 驗證 Token 內容
+	claims := &ConnectionClaims{}
+	parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+
+	require.NoError(t, err)
+	assert.True(t, parsedToken.Valid)
+	assert.Equal(t, userID, claims.Sub)
+	assert.NotNil(t, claims.ExpiresAt)
+	assert.NotNil(t, claims.IssuedAt)
+}
+
+func TestGenerateConnectionToken(t *testing.T) {
+	gen := NewTokenGenerator("test-secret")
+
+	tests := []struct {
+		name    string
+		opts    ConnectionTokenOptions
+		checkFn func(t *testing.T, claims *ConnectionClaims)
+	}{
+		{
+			name: "basic token",
+			opts: ConnectionTokenOptions{
+				UserID: "user-123",
+			},
+			checkFn: func(t *testing.T, claims *ConnectionClaims) {
+				assert.Equal(t, "user-123", claims.Sub)
+				assert.Nil(t, claims.Info)
+				assert.Nil(t, claims.Channels)
+			},
+		},
+		{
+			name: "token with info",
+			opts: ConnectionTokenOptions{
+				UserID: "user-456",
+				Info: map[string]interface{}{
+					"name": "Daniel",
+					"role": "admin",
+				},
+			},
+			checkFn: func(t *testing.T, claims *ConnectionClaims) {
+				assert.Equal(t, "user-456", claims.Sub)
+				assert.NotNil(t, claims.Info)
+				assert.Equal(t, "Daniel", claims.Info["name"])
+				assert.Equal(t, "admin", claims.Info["role"])
+			},
+		},
+		{
+			name: "token with channels",
+			opts: ConnectionTokenOptions{
+				UserID:   "user-789",
+				Channels: []string{"chat:room-1", "chat:room-2"},
+			},
+			checkFn: func(t *testing.T, claims *ConnectionClaims) {
+				assert.Equal(t, "user-789", claims.Sub)
+				assert.Equal(t, []string{"chat:room-1", "chat:room-2"}, claims.Channels)
+			},
+		},
+		{
+			name: "token with custom expire",
+			opts: ConnectionTokenOptions{
+				UserID:   "user-abc",
+				ExpireAt: ptrTime(time.Now().Add(48 * time.Hour)),
+			},
+			checkFn: func(t *testing.T, claims *ConnectionClaims) {
+				assert.Equal(t, "user-abc", claims.Sub)
+				// 檢查過期時間大約在 48 小時後
+				expireTime := claims.ExpiresAt.Time
+				assert.True(t, expireTime.After(time.Now().Add(47*time.Hour)))
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			token, err := gen.GenerateConnectionToken(tt.opts)
+			require.NoError(t, err)
+			assert.NotEmpty(t, token)
+
+			// 解析 Token
+			claims := &ConnectionClaims{}
+			parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+				return []byte("test-secret"), nil
+			})
+
+			require.NoError(t, err)
+			assert.True(t, parsedToken.Valid)
+			tt.checkFn(t, claims)
+		})
+	}
+}
+
+func TestQuickSubscriptionToken(t *testing.T) {
+	gen := NewTokenGenerator("test-secret")
+	userID := "user-123"
+	channel := "private:room-456"
+
+	token, err := gen.QuickSubscriptionToken(userID, channel)
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+
+	// 驗證 Token 內容
+	claims := &SubscriptionClaims{}
+	parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+
+	require.NoError(t, err)
+	assert.True(t, parsedToken.Valid)
+	assert.Equal(t, userID, claims.Sub)
+	assert.Equal(t, channel, claims.Channel)
+}
+
+func TestGenerateSubscriptionToken(t *testing.T) {
+	gen := NewTokenGenerator("test-secret")
+
+	opts := SubscriptionTokenOptions{
+		UserID:  "user-123",
+		Channel: "private:room-456",
+		Info: map[string]interface{}{
+			"role": "moderator",
+		},
+	}
+
+	token, err := gen.GenerateSubscriptionToken(opts)
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+
+	// 驗證 Token 內容
+	claims := &SubscriptionClaims{}
+	parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+
+	require.NoError(t, err)
+	assert.True(t, parsedToken.Valid)
+	assert.Equal(t, opts.UserID, claims.Sub)
+	assert.Equal(t, opts.Channel, claims.Channel)
+	assert.Equal(t, "moderator", claims.Info["role"])
+}
+
+func TestGenerateAnonymousToken(t *testing.T) {
+	gen := NewTokenGenerator("test-secret")
+
+	token, err := gen.GenerateAnonymousToken()
+
+	require.NoError(t, err)
+	assert.NotEmpty(t, token)
+
+	// 驗證 Token 內容
+	claims := &ConnectionClaims{}
+	parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+
+	require.NoError(t, err)
+	assert.True(t, parsedToken.Valid)
+	assert.Equal(t, "", claims.Sub) // 匿名用戶的 UserID 為空
+}
+
+func TestTokenExpiration(t *testing.T) {
+	// 創建一個很短過期時間的生成器
+	gen := NewTokenGeneratorWithConfig(TokenConfig{
+		Secret:   "test-secret",
+		ExpireIn: 1 * time.Second,
+	})
+
+	token, err := gen.QuickConnectionToken("user-123")
+	require.NoError(t, err)
+
+	// 立即驗證應該成功
+	claims := &ConnectionClaims{}
+	parsedToken, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+	require.NoError(t, err)
+	assert.True(t, parsedToken.Valid)
+
+	// 等待過期
+	time.Sleep(2 * time.Second)
+
+	// 過期後驗證應該失敗
+	claims2 := &ConnectionClaims{}
+	_, err = jwt.ParseWithClaims(token, claims2, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "token is expired")
+}
+
+func TestTokenWithWrongSecret(t *testing.T) {
+	gen := NewTokenGenerator("correct-secret")
+
+	token, err := gen.QuickConnectionToken("user-123")
+	require.NoError(t, err)
+
+	// 使用錯誤的密鑰驗證
+	claims := &ConnectionClaims{}
+	_, err = jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
+		return []byte("wrong-secret"), nil
+	})
+
+	assert.Error(t, err)
+}
+
+// 輔助函數
+func ptrTime(t time.Time) *time.Time {
+	return &t
+}

pkg/utils/time.go

@@ -0,0 +1,14 @@
+package utils
+
+import "time"
+
+// GetBucketDay 取得 bucket_day（yyyyMMdd 格式）
+func GetBucketDay(t time.Time) string {
+	return t.Format("20060102")
+}
+
+// GetTodayBucketDay 取得今天的 bucket_day
+func GetTodayBucketDay() string {
+	return GetBucketDay(time.Now())
+}
+

pkg/utils/uuid.go

@@ -0,0 +1,20 @@
+package utils
+
+import (
+	"github.com/google/uuid"
+)
+
+//// GenerateUID 生成匿名 UID
+//func GenerateUID() string {
+//	return fmt.Sprintf("%s%s", consts.AnonUIDPrefix, uuid.New().String()[:8])
+//}
+//
+//// GenerateRoomID 生成房間 ID
+//func GenerateRoomID() string {
+//	return fmt.Sprintf("%s%s", consts.RoomIDPrefix, uuid.New().String())
+//}
+
+// GenerateMessageID 生成訊息 ID
+func GenerateMessageID() string {
+	return uuid.New().String()
+}