README.md:128

• [nitpick] The consolidated Maven command may not build all modules in multi-module setups; verify or split into explicit module build steps for clarity.

mvn clean install -DskipTests=true

cim-common/src/main/java/com/crossoverjie/cim/common/constant/Constants.java:32

• [nitpick] Add JavaDoc for FETCH_OFFLINE_MSG_LIMIT (and related offline status constants) to explain their purpose, valid range, and usage context, or consider grouping them into an enum.

public static final Integer FETCH_OFFLINE_MSG_LIMIT = 100 ;

cim-forward-route/src/main/java/com/crossoverjie/cim/route/constant/Constant.java:29

• [nitpick] Consider renaming OfflineModel to OfflineStoreMode or OfflineStorageType to clarify that these constants represent storage backends.

public final static class OfflineModel {

cim-client-sdk/src/main/java/com/crossoverjie/cim/client/sdk/impl/ClientImpl.java:103

• The RingBufferWheel is instantiated and tasks are added but never started; add a call to ringBufferWheel.start() so the offline fetch job actually runs.

ringBufferWheel = new RingBufferWheel(Executors.newFixedThreadPool(1));

cim-client-sdk/src/main/java/com/crossoverjie/cim/client/sdk/RouteManager.java (1)

83-86: ⚠️ Potential issue

Handle the response payload for offline messages.

This implementation ignores the response from fetchOfflineMsgs, which means fetched offline messages are not processed or delivered to the client.

Implement proper response handling:

-public void fetchOfflineMsgs(Long userId){
+public void fetchOfflineMsgs(Long userId) {
     OfflineMsgReqVO offlineMsgReqVO = OfflineMsgReqVO.builder().receiveUserId(userId).build();
-    routeApi.fetchOfflineMsgs(offlineMsgReqVO);
+    try {
+        BaseResponse<Set<String>> response = routeApi.fetchOfflineMsgs(offlineMsgReqVO);
+        if (response.getCode().equals(StatusEnum.SUCCESS.getCode())) {
+            event.info("Fetched offline messages: {}", response.getDataBody());
+            // Process and deliver messages to client listener
+        } else {
+            event.warn("Failed to fetch offline messages: {}", response.getMessage());
+        }
+    } catch (Exception e) {
+        event.error("Error fetching offline messages", e);
+    }
 }

cim-forward-route/src/main/java/com/crossoverjie/cim/route/config/BeanConfig.java (1)

139-142: Address the hardcoded workerId configuration in SnowflakeIdWorker.

The bean definition is correct, but the underlying SnowflakeIdWorker has a hardcoded workerId = 1L which could cause ID collisions in a clustered environment where multiple instances generate IDs simultaneously.

Consider externalizing the workerId configuration:

 @Bean
 public SnowflakeIdWorker snowflakeIdWorker() {
-    return new SnowflakeIdWorker();
+    return new SnowflakeIdWorker(appConfiguration.getWorkerId());
 }

And update the SnowflakeIdWorker constructor to accept a configurable workerId parameter.

cim-forward-route/src/main/resources/application.yaml (1)

15-19: Remove hard-coded credentials even from commented sections.

Even though the datasource configuration is commented out, it still contains hard-coded credentials that could be accidentally exposed or committed to version control.

Apply this diff to remove the sensitive information:

-#    password: zcyzcy159162
+#    password: ${DB_PASSWORD}

cim-client-sdk/src/main/java/com/crossoverjie/cim/client/sdk/impl/ClientImpl.java (2)

34-34: 🛠️ Refactor suggestion

Address the wildcard import as previously suggested.

This duplicates a previous review comment about avoiding wildcard imports. Please use specific imports instead.

-import java.util.concurrent.*;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;

---

238-238: ⚠️ Potential issue

Add null check before stopping ringBufferWheel.

This addresses a previous review comment about preventing potential NullPointerException.

-        ringBufferWheel.stop(true);
+        if (ringBufferWheel != null) {
+            ringBufferWheel.stop(true);
+            ringBufferWheel = null;
+        }

cim-forward-route/src/main/java/com/crossoverjie/cim/route/controller/RouteController.java (1)

119-121: Review exception flow after offline message saving.

The current implementation saves the offline message but then immediately throws an exception. This could potentially cause issues with transaction rollback or downstream error handling, as noted in previous reviews.

Consider whether the exception should be thrown after successfully saving the offline message, or if a different response pattern would be more appropriate for offline scenarios.

cim-common/src/main/java/com/crossoverjie/cim/common/util/SnowflakeIdWorker.java (1)

8-46: Consider architectural placement based on past feedback.

Based on past review feedback, basic components in the common package should not be handed over to Spring management directly, but should be managed at the application layer (route module).

cim-forward-route/src/main/java/com/crossoverjie/cim/route/service/impl/OfflineMsgServiceImpl.java (1)

46-63: ⚠️ Potential issue

Add safeguards to prevent infinite loop and CPU overuse.

This while(true) loop can cause busy spinning if messages continuously arrive or if there are issues with the persistence layer.

Apply this diff to add safeguards:

+    private static final int MAX_ITERATIONS = 1000;
+    private static final long LOOP_DELAY_MS = 100;
+
     @Override
     public void fetchOfflineMsgs(CIMServerResVO cimServerResVO, Long receiveUserId) {
         String url = "http://" + cimServerResVO.getIp() + ":" + cimServerResVO.getHttpPort();
-        while (true) {
+        int iterationCount = 0;
+        while (iterationCount < MAX_ITERATIONS) {
             List<OfflineMsg> offlineMsgs = offlineMsgStore.fetch(receiveUserId);
             if (offlineMsgs == null || offlineMsgs.isEmpty()) {
                 break;
             }
+            iterationCount++;
             // ... existing logic ...
             offlineMsgStore.markDelivered(receiveUserId, offlineMsgs.stream().map(OfflineMsg::getMessageId).toList());
+            
+            try {
+                Thread.sleep(LOOP_DELAY_MS);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
         }
     }

cim-persistence/cim-persistence-mysql/src/main/resources/mapper/OfflineMsgMapper.xml (1)

61-68: ⚠️ Potential issue

Add missing status filter for consistency.

This query is missing the status=0 condition that's present in fetchOfflineMsgsWithCursor, leading to inconsistent behavior.

Apply this diff to add the missing condition:

     <select id="fetchOfflineMsgIdsWithCursor" resultType="java.lang.Long" parameterType="java.lang.Long">
         SELECT
         message_id
         FROM offline_msg
-        WHERE receive_user_id = #{receiveUserId}
+        WHERE receive_user_id = #{receiveUserId} and status=0
         AND message_id &gt; (select last_message_id from offline_msg_last_send_record where receive_user_id = #{receiveUserId})
         ORDER BY message_id ASC
     </select>

cim-server/src/main/java/com/crossoverjie/cim/server/config/BeanConfig.java (1)

9-9: Remove unused import.

The added import com.fasterxml.jackson.databind.ObjectMapper; is not referenced in this class, resulting in an unused import. Either remove this line or add a corresponding @Bean definition for ObjectMapper if it’s required.

cim-server/src/main/resources/application.yaml (1)

35-36: Excessive blank lines
YAMLlint flags two consecutive blank lines here. Please collapse them to at most one blank line to satisfy lint rules and maintain readability.

🧰 Tools

🪛 YAMLlint (1.37.1)

[warning] 36-36: too many blank lines

(2 > 0) (empty-lines)

docker/wait-for-it.sh (3)

36-40: Quote host/port expansions to avoid word-splitting.

Unquoted $WAITFORIT_HOST/$WAITFORIT_PORT could break on values with spaces or special chars. Wrap them in quotes:

-    nc -z $WAITFORIT_HOST $WAITFORIT_PORT
+    nc -z "$WAITFORIT_HOST" "$WAITFORIT_PORT"
...
-    (echo -n > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
+    (echo -n > "/dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT") >/dev/null 2>&1

---

75-77: Robustly split host:port without word-splitting pitfalls.

Bash arrays for splitting can misbehave; use IFS and read instead:

-        WAITFORIT_hostport=(${1//:/ })
-        WAITFORIT_HOST=${WAITFORIT_hostport[0]}
-        WAITFORIT_PORT=${WAITFORIT_hostport[1]}
+        IFS=: read -r WAITFORIT_HOST WAITFORIT_PORT <<< "$1"

🧰 Tools

🪛 Shellcheck (0.10.0)

[warning] 75-75: Quote to prevent word splitting/globbing, or split robustly with mapfile or read -a.

(SC2206)

---

174-174: Check for non-empty CLI array correctly.

[[ $WAITFORIT_CLI != "" ]] only inspects the first element. Use array length:

-    if [[ $WAITFORIT_CLI != "" ]]; then
+    if [[ ${#WAITFORIT_CLI[@]} -gt 0 ]]; then

🧰 Tools

🪛 Shellcheck (0.10.0)

[warning] 174-174: Expanding an array without an index only gives the first element.

(SC2128)

docker/allin1-ubuntu.Dockerfile (1)

28-29: Optional: Install script to a standard bin directory.

For consistency, consider copying to /usr/local/bin so it’s on PATH and not at root:

-COPY wait-for-it.sh /wait-for-it.sh
-RUN chmod +x /wait-for-it.sh
+COPY wait-for-it.sh /usr/local/bin/wait-for-it.sh
+RUN chmod +x /usr/local/bin/wait-for-it.sh

sql/offline_msg_last_send_record.sql (1)

1-6: Add default timestamp to updated_at Consider defining updated_at with NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP so the column auto-populates and updates on record changes.

sql/offline_msg.sql (1)

1-11: Define defaults and tighten constraints It’s advisable to add NOT NULL and default values, e.g.:

status TINYINT NOT NULL DEFAULT 0,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,

Also evaluate if content or properties should use TEXT instead of VARCHAR(2000) for larger payloads.

cim-forward-route/src/main/java/com/crossoverjie/cim/route/service/AccountService.java (1)

6-6: Remove unused import P2PReqVO is imported but never referenced in this interface. Please remove it to avoid compiler warnings and improve clarity.

sql/01schema.sql (1)

2-2: Consider adding IF NOT EXISTS for idempotency.

The database creation with UTF8MB4 character set is appropriate for international support. However, consider adding IF NOT EXISTS to make the script idempotent.

-create database `cim-test` default character set utf8mb4 collate utf8mb4_general_ci;
+create database if not exists `cim-test` default character set utf8mb4 collate utf8mb4_general_ci;

cim-client/src/main/resources/application.yaml (1)

31-33: Review thread pool sizing.
Increasing the callback queue to 10 while reducing the pool size to 1 may create a processing bottleneck; confirm these settings meet your throughput and latency requirements.

cim-server-api/src/main/java/com/crossoverjie/cim/server/api/vo/res/OfflineMsgResVO.java (2)

3-7: Provide meaningful class-level JavaDoc.
The current Javadoc block is empty; consider adding a description of the VO’s purpose or responsibilities.

---

10-18: Reduce boilerplate and fix formatting.
Consider using Lombok annotations (e.g., @Data) to generate getters/setters automatically and remove the extra space before the semicolon in private String msg ;.

cim-server/src/main/java/com/crossoverjie/cim/server/server/CIMServer.java (1)

93-93: Good implementation of dynamic command support.

This change successfully addresses the past review feedback by making the command dynamic based on the SendMsgReqVO.cmd field, enabling differentiation between regular and offline messages.

Consider adding validation to ensure only valid commands are processed:

 Request.Builder requestBuilder = Request.newBuilder()
         .setRequestId(sendMsgReqVO.getUserId())
         .putAllProperties(sendMsgReqVO.getProperties())
+        .setCmd(sendMsgReqVO.getCmd() != null ? sendMsgReqVO.getCmd() : BaseCommand.MESSAGE);
-        .setCmd(sendMsgReqVO.getCmd());

cim-rout-api/src/main/java/com/crossoverjie/cim/route/api/RouteApi.java (1)

7-7: Consider specific imports over wildcard import.

While wildcard imports reduce clutter, they can hide unused imports and make dependencies less explicit.

cim-server-api/src/main/java/com/crossoverjie/cim/server/api/vo/res/SaveOfflineMsgResVO.java (1)

1-15: Consider using Lombok for cleaner code.

The class follows standard VO patterns but could benefit from modern Java practices for better maintainability.

Apply Lombok annotations to reduce boilerplate:

+import lombok.Data;
+
+@Data
 public class SaveOfflineMsgResVO {
     private String msg;
-
-    public String getMsg() {
-        return msg;
-    }
-
-    public void setMsg(String msg) {
-        this.msg = msg;
-    }
 }

cim-client-sdk/src/main/java/com/crossoverjie/cim/client/sdk/FetchOfflineMsgJob.java (1)

7-7: Consider externalizing the delay configuration.

The hardcoded 5-second delay might not be suitable for all environments. Consider making this configurable through application properties.

-private static final int INITIAL_DELAY_SECONDS = 5;
+private final int delaySeconds;

-public FetchOfflineMsgJob(RouteManager routeManager, ClientConfigurationData conf) {
+public FetchOfflineMsgJob(RouteManager routeManager, ClientConfigurationData conf, int delaySeconds) {
     this.routeManager = routeManager;
     this.conf = conf;
-    setKey(INITIAL_DELAY_SECONDS);
+    this.delaySeconds = delaySeconds;
+    setKey(delaySeconds);
 }

cim-integration-test/src/test/resources/application-route.yaml (1)

16-20: Validate MySQL Testcontainer configuration and credentials handling.

This hardcodes spring.datasource.url to localhost:3306 and expects ${DB_PASSWORD} to be set in the environment. Ensure your CI/Dev environments or Testcontainers override these properties (host, port, credentials) correctly. Consider externalizing or templating the URL/credentials so tests can spin up MySQL containers dynamically.

Would you like a helper script to inject Testcontainer‐driven properties in this YAML or examples for secure password management?

cim-common/src/main/java/com/crossoverjie/cim/common/constant/Constants.java (2)

31-33: Prefer primitive types for constants.

Using int instead of Integer avoids unnecessary boxing/unboxing and clarifies immutability:

-public static final Integer FETCH_OFFLINE_MSG_LIMIT = 100 ;
+public static final int FETCH_OFFLINE_MSG_LIMIT = 100;

---

31-41: Add documentation and grouping for offline-message constants.

The new constants lack Javadoc and are mixed in the root class. Consider extracting them into a nested OfflineMsg or MsgType inner class with proper Javadoc, e.g.:

public static class OfflineMsg {
    /** Maximum number of messages fetched per request. */
    public static final int FETCH_LIMIT = 100;
    /** Pending offline message status. */
    public static final int STATUS_PENDING = 0;
    // ...
}

cim-persistence/cim-persistence-api/src/main/java/com/crossoverjie/cim/persistence/api/service/OfflineMsgStore.java (1)

13-37: Well-designed interface with room for improvement.

The OfflineMsgStore interface provides a clean abstraction for offline message operations. The three core methods (save, fetch, markDelivered) cover the essential functionality needed.

However, consider these improvements:

1. Enhanced Javadoc: Add parameter and return value descriptions:

 /**
  * Save offline message
  *
- * @param offlineMsg
+ * @param offlineMsg the offline message to save
  */
 void save(OfflineMsg offlineMsg);

 /**
  * Fetch offline messages for a user
  *
- * @param userId
- * @return
+ * @param userId the user ID to fetch messages for
+ * @return list of offline messages for the user
  */
 List<OfflineMsg> fetch(Long userId);

2. Consider pagination: The fetch method might need pagination support for users with many offline messages to avoid memory issues and improve performance.

cim-persistence/cim-persistence-api/src/main/java/com/crossoverjie/cim/persistence/api/pojo/OfflineMsg.java (2)

24-25: Consider using enums for better type safety.

The integer constants for messageType and status could be replaced with enums to provide better type safety and clearer API contracts.

Example implementation:

public enum MessageType {
    TEXT(0), IMAGE(1);
    private final int value;
    MessageType(int value) { this.value = value; }
    public int getValue() { return value; }
}

public enum MessageStatus {
    PENDING(0), ACKED(1);
    private final int value;
    MessageStatus(int value) { this.value = value; }
    public int getValue() { return value; }
}

---

28-29: Consider using English for all comments.

For consistency with the rest of the codebase, consider using English for all comments.

Apply this diff:

-    /**
-     * 消息来源存储在这里
-     */
+    /**
+     * Message source properties are stored here
+     */

cim-forward-route/src/main/java/com/crossoverjie/cim/route/service/OfflineMsgService.java (2)

11-16: Enhance JavaDoc with parameter descriptions.

The JavaDoc could be more helpful by describing the parameters and their purposes.

Apply this diff:

     /**
      * fetch offline messages
-     * @param cimServerResVO
-     * @param receiveUserId
+     * @param cimServerResVO the CIM server information where messages should be sent
+     * @param receiveUserId the ID of the user to fetch offline messages for
      */

---

18-22: Enhance JavaDoc with parameter description.

Add parameter description for better API documentation.

Apply this diff:

     /**
      * save offline message
-     * @param p2pRequest
+     * @param p2pRequest the peer-to-peer message request to save as offline message
      */

cim-client-sdk/src/main/java/com/crossoverjie/cim/client/sdk/impl/ClientImpl.java (1)

65-65: Initialize the field to prevent potential issues.

Consider initializing the field to avoid potential null pointer issues during the construction phase.

-private RingBufferWheel ringBufferWheel;
+private RingBufferWheel ringBufferWheel = null;

cim-forward-route/src/test/resources/application.yaml (1)

67-67: Add missing newline at end of file.

Static analysis correctly identified a missing newline character at the end of the file.

 offline:
   store:
     mode: mysql
+

🧰 Tools

🪛 YAMLlint (1.37.1)

[error] 67-67: no new line character at the end of file

(new-line-at-end-of-file)

cim-integration-test/src/main/java/com/crossoverjie/cim/client/sdk/route/OfflineMsgStoreRouteBaseTest.java (1)

34-34: Reconsider container reuse policy for test isolation.

The withReuse(true) setting may cause issues in concurrent test execution or when tests need clean state. Container reuse can lead to test interdependencies and flaky tests.

Consider removing reuse for better test isolation:

-                    .withReuse(true);
+                    .withReuse(false);

cim-persistence/cim-persistence-mysql/src/main/java/com/crossoverjie/cim/persistence/mysql/offlinemsg/mapper/OfflineMsgMapper.java (1)

11-15: Add comprehensive Javadoc documentation.

The class lacks proper documentation describing its purpose, usage, and method behaviors. This is especially important for persistence layer interfaces that define the data access contract.

 /**
- * @author zhongcanyu
- * @date 2025/5/9
- * @description
+ * MyBatis mapper interface for offline message persistence operations.
+ * Provides CRUD operations for managing offline messages in MySQL database.
+ * 
+ * @author zhongcanyu
+ * @date 2025/5/9
  */

cim-forward-route/src/main/java/com/crossoverjie/cim/route/config/OfflineMsgStoreConfig.java (1)

12-16: Add comprehensive class documentation.

The configuration class lacks proper documentation explaining the conditional bean creation and property requirements.

 /**
- * @author zhongcanyu
- * @date 2025/5/18
- * @description
+ * Configuration class for offline message storage implementations.
+ * Conditionally creates beans based on the 'offline.store.mode' property:
+ * - 'mysql': Creates OfflineMsgDb for MySQL-based storage
+ * - 'redis': Creates OfflineMsgBuffer for Redis-based storage
+ * 
+ * @author zhongcanyu
+ * @date 2025/5/18
  */

cim-persistence/cim-persistence-mysql/src/main/java/com/crossoverjie/cim/persistence/mysql/offlinemsg/mapper/OfflineMsgLastSendRecordMapper.java (1)

6-10: Add proper Javadoc documentation.

The class and methods lack meaningful documentation. Add descriptions explaining the purpose and behavior of each method.

 /**
- * @author zhongcanyu
- * @date 2025/5/10
- * @description
+ * Mapper interface for tracking the last sent offline message ID per user.
+ * This helps determine which messages are new when fetching offline messages.
+ * 
+ * @author zhongcanyu
+ * @date 2025/5/10
  */

cim-persistence/cim-persistence-api/src/main/java/com/crossoverjie/cim/persistence/api/config/BeanConfig.java (2)

33-44: Replace Chinese comments with English for consistency.

The codebase appears to use English comments throughout. Please translate the Chinese comments to maintain consistency.

-        // 设置键的序列化器为字符串
+        // Set key serializer to string
         redisTemplate.setKeySerializer(new StringRedisSerializer());

-        // 设置值的序列化器为JSON，支持对象存储
+        // Set value serializer to JSON for object storage support
         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

-        // 设置Hash键和值的序列化器（可选）
+        // Set hash key and value serializers (optional)
         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

-        // 初始化属性
+        // Initialize properties
         redisTemplate.afterPropertiesSet();

---

50-51: Add documentation for the Jackson2HashMapper configuration.

The comment about @class information could be more explanatory for maintainability.

-        // false 表示不在 key 里加 @class 信息
+        // false means do not include @class type information in hash keys
+        // This prevents Jackson from adding type metadata to Redis hash keys
         return new Jackson2HashMapper(objectMapper, false);

cim-persistence/cim-persistence-redis/src/main/java/com/crossoverjie/cim/persistence/redis/OfflineMsgBuffer.java (2)

73-78: Simplify lambda expression.

The lambda can be simplified by removing unnecessary stream operations.

-        messageIds.stream().forEach(messageId -> {
+        messageIds.forEach(messageId -> {
             String key = MSG_KEY + messageId;
             if (Boolean.TRUE.equals(redis.hasKey(key))) {
                 redis.opsForHash().put(key, "status", OFFLINE_MSG_DELIVERED);
             }
         });

---

44-45: Address potential data consistency issues with dual storage approach.

Using both hash storage for messages and list storage for user indexes can lead to consistency issues if one operation fails while the other succeeds.

Consider using Redis transactions or Lua scripts to ensure atomicity:

// Example using Redis transaction
redis.multi();
redis.opsForHash().putAll(key, hashMap);
redis.opsForList().rightPush(USER_IDX + msg.getReceiveUserId(), msg.getMessageId().toString());
redis.exec();

cim-persistence/cim-persistence-api/src/main/java/com/crossoverjie/cim/persistence/api/vo/req/SaveOfflineMsgReqVO.java (2)

15-21: Consider improving field naming consistency.

The field names could be more consistent - msg uses abbreviation while receiveUserId is fully spelled out. Consider using either message and receiveUserId or msg and receiverId for consistency.

-    @NotNull(message = "msg 不能为空")
+    @NotNull(message = "message 不能为空")
     @Schema(requiredMode = Schema.RequiredMode.REQUIRED, description = "msg", example = "hello")
-    private String msg ;
+    private String message;

---

23-25: Remove redundant Lombok annotations.

The @Setter and @Getter annotations on the properties field are redundant since @Data already provides getters and setters for all fields.

-    @Setter
-    @Getter
     private Map<String, String> properties;

cim-client-sdk/src/test/java/com/crossoverjie/cim/client/sdk/OfflineMsgTest.java (1)

51-54: Consider more robust state checking approach.

The current approach captures the state once and then waits for it to become Ready. However, the state is captured before the asynchronous connection process completes. Consider checking the state dynamically within the Awaitility assertion.

-        TimeUnit.SECONDS.sleep(3);
-        ClientState.State state = client1.getState();
         Awaitility.await().atMost(10, TimeUnit.SECONDS)
-                .untilAsserted(() -> Assertions.assertEquals(ClientState.State.Ready, state));
+                .untilAsserted(() -> Assertions.assertEquals(ClientState.State.Ready, client1.getState()));

Also applies to: 70-73

cim-client-sdk/src/test/resources/init.sql (1)

2-27: Consider adding foreign key constraints and improving data types.

The offline_msg table design is generally good but could benefit from a few improvements:

1. Consider adding a foreign key constraint on receive_user_id if there's a users table
2. The properties field using VARCHAR(2000) might be better as JSON type in MySQL 8.0+
3. Consider adding a composite index on (receive_user_id, status) for efficient querying of pending messages

 CREATE TABLE IF NOT EXISTS `offline_msg`
 (
     `id`               BIGINT PRIMARY KEY AUTO_INCREMENT,
     `message_id`       BIGINT NOT NULL,
     `receive_user_id`  BIGINT NOT NULL,
     `content`          VARCHAR(2000),
     `message_type`     INT,
     `status`           TINYINT COMMENT '0: Pending, 1: Acked',
     `created_at`       DATETIME,
-    `properties`       VARCHAR(2000),
+    `properties`       JSON,
     INDEX `idx_receive_user_id` (`receive_user_id`),
+    INDEX `idx_receive_user_status` (`receive_user_id`, `status`)
 );

cim-forward-route/src/test/resources/init.sql (2)

2-27: Fix formatting inconsistencies and add missing engine specification.

The offline_msg table definition has inconsistent formatting and lacks an explicit storage engine specification, unlike the second table.

Apply this diff to improve consistency:

-CREATE TABLE IF NOT EXISTS `offline_msg`
-(
-    `id`
-                   BIGINT
-        PRIMARY
-            KEY
-        AUTO_INCREMENT,
-    `message_id`
-                   BIGINT
-        NOT
-            NULL,
-    `receive_user_id`
-                   BIGINT
-        NOT
-            NULL,
-    `content`
-                   VARCHAR(2000),
-    `message_type` INT,
-    `status`       TINYINT COMMENT '0: Pending, 1: Acked',
-    `created_at`   DATETIME,
-    `properties`   VARCHAR(2000),
-    INDEX `idx_receive_user_id`
-        (
-         `receive_user_id`
-            )
-);
+CREATE TABLE IF NOT EXISTS `offline_msg`
+(
+    `id`              BIGINT PRIMARY KEY AUTO_INCREMENT,
+    `message_id`      BIGINT NOT NULL,
+    `receive_user_id` BIGINT NOT NULL,
+    `content`         VARCHAR(2000),
+    `message_type`    INT,
+    `status`          TINYINT COMMENT '0: Pending, 1: Acked',
+    `created_at`      DATETIME,
+    `properties`      VARCHAR(2000),
+    INDEX `idx_receive_user_id` (`receive_user_id`)
+) ENGINE = InnoDB
+  DEFAULT CHARSET = utf8mb4;

---

17-22: Consider adding NOT NULL constraints and default values.

The schema could benefit from more explicit constraints to ensure data integrity.

Consider these improvements:

-    `content`         VARCHAR(2000),
-    `message_type`    INT,
-    `status`          TINYINT COMMENT '0: Pending, 1: Acked',
-    `created_at`      DATETIME,
-    `properties`      VARCHAR(2000),
+    `content`         VARCHAR(2000) NOT NULL,
+    `message_type`    INT NOT NULL DEFAULT 0,
+    `status`          TINYINT NOT NULL DEFAULT 0 COMMENT '0: Pending, 1: Acked',
+    `created_at`      DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    `properties`      VARCHAR(2000),

cim-persistence/cim-persistence-mysql/src/main/java/com/crossoverjie/cim/persistence/mysql/util/MapToJsonTypeHandler.java (1)

22-22: Consider thread safety and configurability of ObjectMapper.

The static ObjectMapper instance may need configuration for specific JSON handling requirements and thread safety considerations.

Consider making the ObjectMapper configurable:

-    private static final ObjectMapper objectMapper = new ObjectMapper();
+    private static final ObjectMapper objectMapper = createObjectMapper();
+    
+    private static ObjectMapper createObjectMapper() {
+        ObjectMapper mapper = new ObjectMapper();
+        // Add any specific configuration here
+        return mapper;
+    }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

cim-common/src/main/java/com/crossoverjie/cim/common/util/HttpClient.java (1)

46-48: 🛠️ Refactor suggestion

Apply consistent error reporting to the get method.

The get method still uses the old generic error message format, which is inconsistent with the improved error reporting in the post method. Apply the same enhancement for consistency.

-        if (!response.isSuccessful()) {
-            throw new IOException("Unexpected code " + response);
-        }
+        if (!response.isSuccessful()) {
+            throw new IOException("request url [" + url + "] failed, response code: " + response.code()
+                    + ", message: " + response.message());
+        }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

cim-persistence/cim-persistence-mysql/src/main/resources/mapper/OfflineMsgLastSendRecordMapper.xml (1)

5-13: Verify unique index exists for optimal performance.

The INSERT...ON DUPLICATE KEY UPDATE statement requires a unique index on receive_user_id for correct functionality and optimal performance.

#!/bin/bash
# Check for database schema or migration files that create the required index
fd -e sql | xargs grep -l "offline_msg_last_send_record" | head -5

cim-persistence/cim-persistence-mysql/src/main/java/com/crossoverjie/cim/persistence/mysql/offlinemsg/mapper/OfflineMsgLastSendRecordMapper.java (2)

9-10: Empty JavaDoc description should be completed or removed.

The @description tag is empty. Either provide a meaningful description of this mapper's purpose or remove the empty tag.

 /**
  * @author zhongcanyu
  * @date 2025/5/10
- * @description
+ * @description Mapper for managing offline message last send records to track message delivery status
  */

---

14-14: Add space after comma in parameter list for better readability.

Missing space between parameters affects code readability.

-    void saveLatestMessageId(@Param("receiveUserId") Long receiveUserId,@Param("lastMessageId") Long lastMessageId);
+    void saveLatestMessageId(@Param("receiveUserId") Long receiveUserId, @Param("lastMessageId") Long lastMessageId);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro