refactor(modules): update C++20 module files for upstream ecosystem changes (#223) (#234)

* refactor(modules): update C++20 module files for upstream ecosystem changes (Issue #223)

- Update transport_interface to match actual header API:
  disconnect() returns VoidResult, rename state() to get_state(),
  replace send_async() with send_binary(), add statistics methods
- Replace transport_options with transport_config/transport_statistics
- Rewrite websocket_transport with proper config and topic methods
- Rewrite http_transport with http_content_type and config structs
- Replace resilient_transport with retry_config, circuit_breaker_config,
  resilient_transport_config, and resilience_statistics from Issue #221
- Add messaging_error_category and make_messaging_error_code to core
  partition from Issue #229
- Add health check adapter exports (messaging_health_check,
  queue_health_check, transport_health_check) from Issue #222
- Add composite check and registration helper exports

* fix(modules): resolve C++20 module build configuration issues

- Fix INTERFACE library target handling in UnifiedDependencies.cmake
  (use INTERFACE keyword instead of PUBLIC for INTERFACE targets)
- Link messaging_system_modules to messaging_system_core for proper
  upstream include path propagation during dependency scanning
- Remove non-existent kcenon.logger module import (logging is part
  of kcenon.common:logging partition)
- Replace kcenon.database import with kcenon.monitoring (database_system
  has upstream CMake module build bug)
- Use foreach loop for cleaner upstream module target linking

Author: kcenon

CMakeLists.txt

@@ -476,33 +476,28 @@ if(MESSAGING_BUILD_MODULES)
             $<INSTALL_INTERFACE:include>
         )
 
-        # Link dependencies - module targets from dependent systems
-        # Note: These targets must be available when building with modules
-        if(TARGET kcenon::common_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::common_modules)
-        endif()
-        if(TARGET kcenon::thread_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::thread_modules)
-        endif()
-        if(TARGET kcenon::container_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::container_modules)
-        endif()
-        if(TARGET kcenon::logger_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::logger_modules)
-        endif()
-        if(TARGET kcenon::database_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::database_modules)
-        endif()
-        if(TARGET kcenon::network_modules)
-            target_link_libraries(messaging_system_modules PUBLIC kcenon::network_modules)
-        endif()
-
-        # Also link header-based targets for implementation files
-        if(TARGET ${container_system_TARGET})
-            target_link_libraries(messaging_system_modules PRIVATE ${container_system_TARGET})
-        elseif(TARGET container)
-            target_link_libraries(messaging_system_modules PRIVATE container)
-        endif()
+        # Link dependencies for module compilation.
+        # The global module fragment #includes upstream headers (e.g., core/container.h),
+        # so we need their include directories available during dependency scanning.
+        # Link to messaging_system_core (PRIVATE) to transitively get all upstream
+        # include paths, then optionally link upstream module targets (PUBLIC) when
+        # they become available.
+        target_link_libraries(messaging_system_modules PRIVATE messaging_system_core)
+
+        # When upstream systems provide C++20 module targets, link them publicly
+        # so consumers can import the full module dependency chain.
+        foreach(_mod_target
+            kcenon::common_modules
+            kcenon::thread_modules
+            kcenon::container_modules
+            kcenon::logger_modules
+            kcenon::database_modules
+            kcenon::network_modules
+        )
+            if(TARGET ${_mod_target})
+                target_link_libraries(messaging_system_modules PUBLIC ${_mod_target})
+            endif()
+        endforeach()
 
         # Define compile-time flags
         target_compile_definitions(messaging_system_modules PUBLIC

cmake/UnifiedDependencies.cmake

@@ -482,7 +482,12 @@ macro(_unified_resolve_fetchcontent DEP_NAME GIT_TAG)
                 if(TARGET "${_ts_target}")
                     get_target_property(_aliased "${_ts_target}" ALIASED_TARGET)
                     if(NOT _aliased)
-                        target_compile_definitions("${_ts_target}" PUBLIC USE_STD_FORMAT)
+                        get_target_property(_ts_type "${_ts_target}" TYPE)
+                        if(_ts_type STREQUAL "INTERFACE_LIBRARY")
+                            target_compile_definitions("${_ts_target}" INTERFACE USE_STD_FORMAT)
+                        else()
+                            target_compile_definitions("${_ts_target}" PUBLIC USE_STD_FORMAT)
+                        endif()
                     endif()
                 endif()
             endforeach()

src/modules/core.cppm

@@ -813,3 +813,46 @@ constexpr std::string_view get_error_message(int code) noexcept {
 }
 
 } // namespace kcenon::messaging::error
+
+// =============================================================================
+// Error Category
+// =============================================================================
+
+export namespace kcenon::messaging {
+
+/**
+ * @class messaging_error_category
+ * @brief Error category for messaging_system typed error codes
+ *
+ * Integrates with common_system's typed_error_code infrastructure.
+ * Singleton pattern, thread-safe via C++11 static local initialization.
+ */
+class messaging_error_category : public common::error_category {
+public:
+    static const messaging_error_category& instance() noexcept {
+        static messaging_error_category inst;
+        return inst;
+    }
+
+    std::string_view name() const noexcept override {
+        return "messaging";
+    }
+
+    std::string message(int code) const override {
+        return std::string(error::get_error_message(code));
+    }
+
+private:
+    messaging_error_category() = default;
+};
+
+/**
+ * @brief Create a typed_error_code for a messaging error code
+ * @param code Messaging error code (from error:: namespace)
+ * @return typed_error_code with messaging_error_category
+ */
+inline common::typed_error_code make_messaging_error_code(int code) noexcept {
+    return common::typed_error_code(code, messaging_error_category::instance());
+}
+
+} // namespace kcenon::messaging