finesoft/corantce

This system is a modular Java microservice framework built on CDI and MicroProfile standards, providing a comprehensive suite of infrastructure modules for enterprise application development. It offers integrated capabilities for data persistence (JPA, Elasticsearch, MongoDB), distributed transactions (JTA/Narayana), messaging (JMS), and security (JWT, Keycloak), alongside utilities for configuration, caching, and internationalization. The framework also includes specialized modules for DevOps tooling, cloud service integrations, and domain-driven design patterns, enabling developers to assemble robust, scalable services with declarative configuration and automatic dependency injection.

169 changes.

The project underwent a major structural shift, migrating legacy 'suites' into a comprehensive 'modules' hierarchy to support a wide array of new integrations including JPA, JMS, Elasticsearch, and cloud services. This period involved significant refactoring of the core kernel, configuration, and shared utilities to establish a robust, CDI-based microservice foundation. Concurrently, extensive new features were added for data access, messaging, and security, while older implementations like Tomcat and legacy DDD models were removed.

17 changes.

This period focused on integrating the Corant framework with the Vert.x ecosystem, introducing CDI extensions for service proxies, event bus consumers, and JAX-RS verticles. Concurrently, the project expanded its core capabilities by adding a comprehensive retry framework, BSON serialization support, and a new Jetty-based web server implementation. Additional work included establishing validation infrastructure, enabling MicroProfile health checks, and introducing scripting abstractions alongside various test coverage improvements.

This change introduces a new integration module for Alibaba Cloud Object Storage Service (OSS) within the corant-modules-cloud-alibaba package. It provides a declarative configuration class (OSSClientConfiguration) that maps to the 'corant.cloud.alibaba.oss' property prefix, allowing users to define endpoints, credentials, and bucket lists via configuration. The module includes a CDI extension (OSSClientExtension) and producer (OSSClientProducer) that automatically instantiate OSS clients and wrap them in a unified OSSStorageService for each configured bucket, supporting injection via the @Naming qualifier. The storage service handles resource operations (get/store) and manages client lifecycle, while also incorporating shared resource processing utilities like ContentDispositions.

corant-modules/corant-modules-cloud/corant-modules-cloud-alibaba/src/main/java/org/corant/modules/cloud/alibaba/oss · high confidence

Introduces the new corant-modules-jms-artemis module, providing configuration support for Apache ActiveMQ Artemis brokers via the ArtemisConfig class (mapping properties like URL, host/port pairs, and HA settings) and a CDI extension (ArtemisJMSExtension) that automatically registers ActiveMQConnectionFactory beans based on these configurations.

corant-modules/corant-modules-jms/corant-modules-jms-artemis/src/main/java/org/corant/modules/jms · high confidence

The corant-modules-json module now includes a new BSON handling layer. This adds a utility class for converting between BSON bytes and Java maps/documents, along with an extended codec provider that enables serialization for a wide range of Java types. Specifically, it adds support for Java 8 date/time types (such as ZonedDateTime, LocalTime, Duration, and Period), mathematical types (BigDecimal, BigInteger), and utility types (Currency, Locale, URI, URL, Class, and Serializable objects).

corant-modules/corant-modules-json/src/main/java/org/corant/modules/bson · high confidence

This change introduces new CDI producer classes and service provider configurations to integrate XA-Disk, Hibernate OGM, and Redisson into the application context. The \corant-modules-jta-xadisk\ module adds \XAFileSystemProducer\ and \XADiskSessionProducer\ to manage XA-Disk file systems and transaction-scoped sessions, with configuration properties (e.g., \corant.jta.xadisk.\*\) controlling disk home, cluster mode, and buffer settings. The \corant-modules-jpa-hibernate-ogm\ module registers the \ExtendedHibernateOgmPersistenceProvider\ via \META-INF/services\ and defines a \beans.xml\ to enable annotated bean discovery. The \corant-modules-redis\ module provides a \RedissonClientProducer\ that creates and disposes \Redisson\ clients based on configuration properties like \corant.redis.address\, \database\, \password\, and \timeout\. These components are marked as unfinished in their source comments but provide the wiring for these technologies.

corant-modules/corant-modules-jpa/corant-modules-jpa-hibernate-ogm, corant-modules/corant-modules-jta/corant-modules-jta-xadisk/src/main/java/org/corant/modules/jta, corant-modules/corant-modules-redis/src/main/java/org/corant/modules/redis · high confidence

The new \corant-modules-jcache-caffeine\ module provides a CDI extension that integrates Caffeine as the caching provider for JCache. It registers the Caffeine caching provider and supports configuration via a dedicated resource file or by mapping properties prefixed with \corant.jcache.caffeine.\ or \caffeine.jcache.\. It also includes a custom serialization copier that treats specific Corant utility classes (Pair, Triple, Range) as immutable to optimize store-by-value strategies.

corant-modules/corant-modules-jcache/corant-modules-jcache-caffeine/src/main/java/org/corant/modules/jcache · high confidence

The datasource module now includes a new DBCP (Apache Commons DBCP2) implementation for managed data sources. This adds a CDI extension that registers BasicManagedDataSource beans, integrates with Narayana JTA for transaction management, and allows configuration via the new DBCPDataSourceConfigurator SPI. Users can now obtain managed DBCP data sources through standard CDI injection.

corant-modules/corant-modules-datasource/corant-modules-datasource-dbcp/src/main/java/org/corant/modules/datasource · high confidence

This change introduces new components to the corant-modules-mvc module to support Freemarker as a view technology. It adds a configuration class (FreemarkerServletConfig) to define initialization parameters and URL patterns, a provider (FreemarkerServletProiver) that registers the FreemarkerServlet with the web container based on that configuration, and a view class (FreemarkerView) extending Resteasy's View to facilitate rendering. These files represent the specific implementation details for integrating Freemarker into the MVC layer.

corant-modules/corant-modules-mvc/src/main/java/org/corant/modules/mvc · high confidence

The module now provides concrete implementations for executing JavaScript scripts using both the GraalVM JavaScript engine (GraalJSScriptEngineService) and the legacy Nashorn engine (NashornScriptEngineService). These services allow applications to compile and run JavaScript code, supporting both simple script execution and pre-compiled consumers/functions for better performance. The Nashorn implementation is marked for removal as it relies on deprecated JDK APIs, while the GraalJS implementation offers a modern alternative with full host access and Nashorn compatibility options.

corant-modules/corant-modules-lang/corant-modules-lang-javascript/src/main/java/org/corant/modules/lang · high confidence

This change introduces a new module for integrating JPA with MongoDB via Hibernate OGM. It provides a custom persistence provider that automatically configures JTA and CDI bean manager settings, and includes a MongoDB-specific dialect to map Java 8 date/time types (Instant, LocalDate, LocalDateTime, ZonedDateTime) and BigDecimal to the grid store. Additionally, it adds a session time service to retrieve the MongoDB server's local time for accurate timestamping.

corant-modules/corant-modules-jpa/corant-modules-jpa-hibernate-ogm/src/main/java/org/corant/modules/jpa · high confidence

This change registers the JsonConfigSourceResolverImpl to enable JSON-based configuration source resolution via Java SPI. It also introduces a suite of BSON data converters (handling types like DateTime, ObjectId, Regex, and DbPointer) and specific converter factories for Jackson JPA tuples and JSON numbers, allowing seamless conversion between JSON/BSON formats and Java types.

corant-modules/corant-modules-json · high confidence

Introduces the \corant-modules-keycloak-client\ module, providing CDI-managed wrappers for Keycloak administration and authorization. The new \KeycloakAdmin\ class builds admin \Keycloak\ instances using either a JSON configuration string/location or explicit properties (server URL, realm, credentials), while \KeycloakAuthzClient\ handles authorization flows including access token retrieval and refresh. A \KeycloakTestUtils\ helper is also included to facilitate testing by resolving OIDC token parameters from configuration.

corant-modules/corant-modules-keycloak/corant-modules-keycloak-client/src/main/java/org/corant/modules/keycloak · high confidence

This module introduces the ability to compile Kotlin source files and execute Kotlin scripts within the application. It provides a CompilationService interface and implementation to handle Kotlin-to-JVM compilation, as well as a ScriptEngineService that integrates with the Java Scripting API to allow dynamic execution of Kotlin scripts (\.kts\) with parameter binding. The changes include the new service implementations, a utility class for script engine access, and the necessary META-INF service registrations to make these capabilities discoverable by the framework.

corant-modules/corant-modules-lang/corant-modules-lang-kotlin/src/main/java/org/corant/modules/lang · high confidence

Users can now define and execute query scripts using the Kotlin language. A new KotlinScriptProcessor has been introduced to handle Kotlin-based scripts (identified by the KT type), leveraging the existing script engine service infrastructure. The processor supports pre-compilation of Kotlin scripts upon deployment if verification is enabled, improving performance by caching compiled script logic.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic/kotlin · high confidence

This change introduces a new LRA module for the Corant MicroProfile integration, enabling Last Participant Optimization for distributed transactions. It adds configuration support via \LRAConfig\ (defaulting to localhost:8089) and registers the necessary JAX-RS filters (\ClientLRARequestFilterExt\, \ClientLRAResponseFilterExt\) and providers (\ServerLRAFilter\, \ParticipantStatusOctetStreamProvider\) as CDI beans through \LRAExtension\. This allows applications to participate in LRA-based distributed transactions by automatically handling coordinator host/port settings and request/response filtering.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-lra/src/main/java/org/corant/modules/microprofile · high confidence

The healthcheck module now exposes standard MicroProfile Health endpoints (health, liveness, readiness, startup, wellness, and group) via dedicated servlets. These endpoints are enabled by default but can be toggled via configuration properties (e.g., \corant.microprofile.health-check.health.endpoint.enable\) and their URLs are customizable. The readiness check specifically tracks the application's startup and shutdown lifecycle, reporting ready only after the container is fully initialized.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-healthcheck/src/main/java/org/corant/modules/microprofile · high confidence

This change introduces the corant-modules-microprofile-jwt module, providing a complete integration layer for MicroProfile JWT authentication and authorization. It adds an authenticator (MpJWTAuthenticator) that parses JWT tokens using SmallRye's JWTParser, an authorizer (MpJWTAuthorizer) that maps JWT claims to roles and permissions, and security context managers that bind the parsed JWT principal to the application's security context for both JAX-RS and Servlet environments.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-jwt/src/main/java/org/corant/modules/microprofile/jwt · high confidence

Added a new \com.github.wxpay.sdk\ package containing the Tencent WeChat Pay Java SDK (version 3.0.9) to enable payment processing. This includes the core \WXPay\ client, configuration via \CorantWXPayConfig\ (supporting declarative config keys like \corant.cloud.tencent.wechat.pay\), and a CDI provider (\CorantWXPayProvider\) for dependency injection. The implementation also includes XML parsing utilities with secure processing features, domain management for API routing, and transaction reporting capabilities.

corant-modules/corant-modules-cloud/corant-modules-cloud-tencent/src/main/java · high confidence

This change introduces the Undertow web server module, providing a new implementation of the web server interface backed by the Undertow engine. It includes a file-system-based session persistence manager that serializes HTTP sessions to disk (configurable via \corant.webserver.undertow.session-persistence-path\), and custom resource managers (\UndertowClassPathResourceManager\ and \UndertowMixedResourceManager\) to handle static content serving from classpaths and mixed sources. The module also exposes extensive configuration options for Undertow-specific settings such as IO threads, buffer sizes, HTTP/2 support, and WebSocket buffer pools via \UndertowWebServerConfig\.

corant-modules/corant-modules-webserver/corant-modules-webserver-undertow/src/main/java/org/corant/modules/webserver · high confidence

The embeddable Quartz module now supports declarative job scheduling. Developers can annotate methods with @CorantTrigger to define cron expressions, start/end times, and priorities. The framework automatically detects these annotations via a CDI extension, registers the jobs with an embedded Quartz scheduler, and executes them using a custom job factory that leverages contextual method handlers.

corant-modules/corant-modules-quartz/corant-modules-quartz-embeddable/src/main/java/org/corant/modules/quartz/embeddable · high confidence

This change introduces a new set of JDBC drivers for the Narayana JTA object store that support database-specific domain isolation. The core \AbstractDomainJDBCDriver\ and its concrete implementations for DB2, Microsoft SQL Server, MySQL, Oracle, and PostgreSQL now include a \domain\ field and filter all SQL queries by this domain, allowing multiple logical domains to share the same database tables without conflict. Additionally, each driver implements database-specific error handling for table creation and dropping, and configures the correct SQL type for object state storage (e.g., BLOB, VARBINARY(MAX)).

corant-modules/corant-modules-jta/corant-modules-jta-narayana/src/main/java/org/corant/modules/jta/narayana/objectstore/driver · high confidence

This change introduces a new CDI extension that automatically discovers interfaces annotated with @ProxyGen and registers them as injectable beans. Users can now inject these service proxies directly into their application components using the new @ServiceProxy qualifier, which allows specifying the service address. The implementation handles the creation of the underlying Vert.x service proxy and ensures that asynchronous result handlers are executed on the appropriate executor, simplifying the integration of Vert.x services with CDI-managed beans.

corant-modules/corant-modules-vertx/corant-modules-vertx-serviceproxy, corant-modules/corant-modules-vertx/corant-modules-vertx-serviceproxy/src/main/java/org/corant/modules/vertx · high confidence

The shared datasource module now includes comprehensive English and Chinese error message mappings for standard SQL states (e.g., connection exceptions, data integrity violations) to improve diagnostic clarity. Additionally, it registers specific field processors for BLOB, CLOB, and NCLOB types via the Java SPI mechanism, enabling automatic conversion of these large object types to byte arrays and strings during SQL queries.

corant-modules/corant-modules-datasource/corant-modules-datasource-shared · high confidence

This change introduces a new REST client interface, WechatOAuthClient, for interacting with the Tencent WeChat OAuth API endpoints (including token validation, acquisition, refresh, and user info retrieval) using MicroProfile Rest Client. It also adds a corresponding configuration class, WechatOAuthConfig, to manage OAuth settings such as appid, secret, and redirect URI, alongside necessary package metadata files.

corant-modules/corant-modules-cloud/corant-modules-cloud-tencent/src/main/java/org/corant/modules/cloud · high confidence

The Maven plugin now includes a set of resource scripts (run.sh, run.bat, runw.sh, runw.bat, start.bat, stop.bat, etc.) and a jvm.options file to facilitate application deployment and execution. These scripts allow users to launch the application with configurable JVM arguments, classpaths, and system properties, supporting both console and windowed modes on Windows and Unix-like systems.

corant-devops/corant-devops-maven/corant-devops-maven-plugin/src/main/resources · high confidence

The unit test module now includes an additional configuration source provider, org.corant.devops.test.AddiConfigPropertyProvider, alongside the existing RandomWebServerPortSourceProvider. This allows unit tests to access a broader set of configuration properties during execution.

corant-devops/corant-devops-test/corant-devops-test-unit/src/main/resources · high confidence

The \corant-modules-quartz-embeddable\ module now includes a new \cron\ package containing the foundational interfaces and classes for parsing cron expressions. This includes \CronExpAST\ and \CronExpNode\ for the abstract syntax tree structure, \CronExpVisitor\ for traversal, and \CronExpParser\ with a \parse\ method that currently returns null. These components are marked as incomplete and serve as the structural basis for future cron expression support.

corant-modules/corant-modules-quartz/corant-modules-quartz-embeddable/src/main/java/org/corant/modules/quartz/embeddable/cron · high confidence

Added English (en\_US) and Chinese (zh\_CN) resource files that provide localized display names for the Aggregate Lifecycle enum states (such as Initialize, Preserved, Loaded, and Destroyed). This ensures that lifecycle status messages are presented in the user's preferred language rather than raw enum identifiers.

corant-modules/corant-modules-ddd/corant-modules-ddd-api · high confidence

New META-INF/services files have been added to register specific converter implementations (such as Blob-to-byte array, Clob-to-String, and various type conversions) and converter factories (including object-enum, string-object, and temporal list/map factories) with the framework's service loader mechanism, enabling automatic discovery of these conversion capabilities.

corant-shared/src/main/resources · high confidence

The Cassandra query module now includes CDI support, introducing the \@CasQuery\ qualifier and the \CasNamedQueryServiceManager\ to manage named query services. This allows applications to inject \FetchableNamedQueryService\ instances via the \@CasQuery\ annotation, with the manager handling service creation, caching, and lifecycle management based on configured cluster names and fetch sizes.

corant-modules/corant-modules-query/corant-modules-query-cassandra/src/main/java/org/corant/modules/query/cassandra/cdi · high confidence

Added CDI integration components for the Elastic and JPQL query modules. The Elastic module now includes an \EsNamedQueryServiceManager\ and an \@EsQuery\ qualifier to manage and inject named query services backed by Elasticsearch clusters, while the JPQL module provides a corresponding \JpqlNamedQueryServiceManager\ and \@JpqlQuery\ qualifier for injecting services tied to JPA persistence units. These managers handle service lifecycle, caching, and injection point resolution, enabling applications to obtain typed query services via standard CDI injection.

corant-modules/corant-modules-query/corant-modules-query-elastic/src/main/java/org/corant/modules/query/elastic/cdi, corant-modules/corant-modules-query/corant-modules-query-jpql/src/main/java/org/corant/modules/query/jpql/cdi · high confidence

The \corant-modules-ddd-api\ module has been reorganized, moving core classes like \AbstractEvent\ from the previous \corant-asosat-ddd\ location to the new \org.corant.modules.ddd\ package. This change introduces several new DDD primitives, including \Aggregate\, \TypedRepository\, \SagaService\, \UnitOfWorksManager\, and \MessageDispatcher\, alongside updated lifecycle management via \AggregateLifecycleManager\. Existing interfaces such as \Entity\ and \AggregateAssistant\ have been refined to support new capabilities like current unit-of-work tracking and asynchronous event firing, while \Repository\ is now complemented by a type-safe \TypedRepository\ variant.

corant-modules/corant-modules-ddd/corant-modules-ddd-api/src/main/java/org/corant/modules/ddd · high confidence

The health-check module now includes configuration files that activate all standard MicroProfile health endpoints (health, liveness, readiness, startup, and wellness) out of the box. Users will have these diagnostic endpoints available immediately without needing to manually enable them, as the module sets specific properties to true and configures CDI bean discovery for the annotated health checks.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-healthcheck · high confidence

The conversion module in corant-shared has been significantly enhanced with new converters for SQL types (Blob to byte array, Clob to String, and various java.time to java.sql.Date/Timestamp mappings), improved string-to-date parsing with extensive pattern support, and new converters for Duration and Character. Additionally, existing converter classes have been refactored to follow a consistent constructor pattern and renamed to correct spelling (e.g., Conveter to Converter).

corant-shared/src/main/java/org/corant/shared/conversion/converter · high confidence

The conversion framework in corant-shared now supports a broader range of data types. Users can convert byte arrays to primitive numbers (Long, Integer, Short, Character, Float, Double) and vice versa, and convert Date objects to Java 8 temporal types (Instant, ZonedDateTime, OffsetDateTime, LocalDateTime, LocalDate). Additionally, int arrays and Lists can be converted to LocalDate, LocalDateTime, and LocalTime, while Maps can be converted to Instant, LocalDate, LocalDateTime, and LocalTime. The system also handles conversions from various Number types to primitive arrays (boolean, byte, short, int, long, float, double) and provides an implicit String-to-Object converter that leverages static factory methods or constructors. The ObjectEnumConverterFactory has been updated to support conversion from Maps and various numeric types, with configurable case sensitivity.

corant-shared/src/main/java/org/corant/shared/conversion/converter/factory · high confidence

This change introduces the FXObservableModule, a new Jackson databind module that enables automatic deserialization of JavaFX Observable collections (ObservableList, ObservableSet, ObservableMap) and ObjectProperty. By registering this module, applications can now map JSON directly to these JavaFX types, though the implementation is marked as experimental and not recommended for production use.

corant-modules/corant-modules-javafx/corant-modules-javafx-jackson, corant-modules/corant-modules-javafx/corant-modules-javafx-jackson/src/main/java/org/corant/modules/javafx · high confidence

The servlet module now supports HTTP range requests, allowing clients to request specific byte ranges of a resource. This is implemented via the new HttpRanges utility for parsing Range and If-Range headers and the HttpStreamOutput class, which handles partial content responses (206), sets appropriate Content-Range headers, and manages multipart byte ranges. This enables efficient streaming of large files by downloading only the required segments.

corant-modules/corant-modules-servlet/src/main/java/org/corant/modules/servlet · high confidence

The \corant-modules-query-elastic\ module is introduced, providing the core infrastructure for querying Elasticsearch. This includes the \AbstractEsNamedQueryService\ for executing named queries (search, aggregation, scrolling), \DefaultEsNamedQuerier\ for handling query parameters and result limits, and \DefaultEsQueryExecutor\ for low-level transport client interactions. The module also adds \EsScrollableSpliterator\ for efficient large-result-set iteration and utility classes like \XContentUtils\ to handle Elasticsearch JSON parsing and registry configuration.

corant-modules/corant-modules-query/corant-modules-query-elastic/src/main/java/org/corant/modules/query/elastic · high confidence

Added the core Jetty integration for the Corant web server module, introducing the \JettyWebServer\ class to manage the lifecycle (start/stop) of the embedded Jetty server and CDI integration, along with a \JettyWebServerThreadPoolProvider\ interface and its default implementation to configure thread pools based on application settings.

corant-modules/corant-modules-webserver/corant-modules-webserver-jetty/src/main/java/org/corant/modules/webserver · high confidence

This change introduces the new \corant-modules-mongodb\ module, providing a complete MongoDB integration layer for the Corant framework. It includes a CDI extension (\MongoClientExtension\) that automatically discovers and registers \MongoClient\ and \MongoDatabase\ beans based on configuration properties (e.g., \corant.mongodb.\*\), supporting both named and default clients. The module offers static utility classes (\Mongos\) for common database operations like cloning/copying collections and databases, and handles JNDI binding if configured. Users can now inject MongoDB clients and databases directly into their application beans.

corant-modules/corant-modules-mongodb/src/main/java/org/corant/modules/mongodb · high confidence

This change introduces the new \corant-modules-elastic-data\ module, providing the core infrastructure for connecting to and managing Elasticsearch clusters. It includes \ElasticConfig\ for declarative configuration of cluster nodes and settings, an \ElasticExtension\ that registers CDI beans for \TransportClient\, \ElasticDocumentService\, and \ElasticIndicesService\, and utility classes like \ElasticDeveloperKits\ for debugging. The module also adds \Elastic6Constants\ for Elasticsearch 6.x defaults and an \ElasticException\ type, effectively replacing the previous location of the package-info file in the servlet suites.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data · high confidence

The Corant datasource module now supports Agroal as the underlying connection pool implementation. This change adds an extension that automatically registers AgroalDataSource beans, configures connection pool settings (such as size, timeouts, and validation), and exposes JMX metrics for monitoring pool health. It also introduces a configurator interface to allow custom tuning of the Agroal configuration before the data source is created.

corant-modules/corant-modules-datasource/corant-modules-datasource-agroal/src/main/java/org/corant/modules/datasource/agroal · high confidence

This change adds a new set of classes in the \corant-modules-vertx-shared\ module to integrate the Corant application framework with Vert.x. It introduces \CorantVerticle\ and \Verticles\ to manage the lifecycle of the Corant container within a Vert.x environment, including startup and shutdown hooks. A \VertxExtension\ implements the CDI SPI to register \Vertx\, \Context\, and \EventBus\ beans, and to discover and register CDI observer methods as Vert.x event bus consumers via the \@VertxConsumer\ qualifier. The implementation also includes \VertxAsynchronousReference\ and \VertxAsynchronousWorker\ to support asynchronous dependency injection and non-blocking worker tasks, adapting logic from the Weld-Vertx project to keep it synchronized with current dependencies.

corant-modules/corant-modules-vertx/corant-modules-vertx-shared/src/main/java/org/corant/modules/vertx · high confidence

The corant-context module now includes a new command handling subsystem that allows developers to define command objects and their corresponding handlers using CDI. This feature introduces the CommandHandler interface and AbstractCommandHandler base class, along with a CommandExtension that automatically discovers and registers command-handler pairs at deployment time. A CommandHandlerResolver is provided to look up and execute the appropriate handler for a given command, supporting qualifier-based resolution and optional command validation via the CommandValidator interface.

corant-context · high confidence

This change adds the \corant-modules-query-cassandra\ module, providing a new Cassandra-specific implementation for the query framework. It introduces core components including \AbstractCasNamedQueryService\ for executing named queries, \DefaultCasQueryExecutor\ for handling CQL execution with paging and timeout support, and \CasMapHandler\ for mapping Cassandra rows to Java maps. The module also includes \DefaultCasNamedQuerierResolver\ for resolving query builders and \CasTemplateMethodModelEx\ for Freemarker template processing, enabling users to perform data access against Cassandra databases using the existing query abstractions.

corant-modules/corant-modules-query/corant-modules-query-cassandra/src/main/java/org/corant/modules/query/cassandra · high confidence

The \corant-modules-elastic-data\ module now provides a new service layer for Elasticsearch operations. This includes the \ElasticDocumentService\ interface and its \AbstractElasticDocumentService\ implementation, which enable batch indexing, single document indexing, deletion by ID or query, and search with sorting and field selection. Additionally, the \ElasticIndicesService\ interface and \AbstractElasticIndicesService\ implementation allow for creating, deleting, checking existence, and retrieving settings for Elasticsearch indices. An \ElasticTransportClientService\ is also added to manage the injection and retrieval of \TransportClient\ instances based on cluster names.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data/service · high confidence

The new corant-modules-flyway module provides automatic database migration capabilities using Flyway. It registers a CDI extension that triggers migration after deployment, allowing users to configure migration locations and enable/disable the process via the corant.flyway.migrate configuration prefix. The module supports multiple data sources, resolves them via JNDI or the internal DataSourceService, and allows customization through callbacks, Java migrations, and resolvers.

corant-modules/corant-modules-flyway/src/main/java/org/corant/modules/flyway · high confidence

Added a new Freemarker integration package for the query module, providing the infrastructure to execute dynamic queries using Freemarker templates. This includes the \FreemarkerExecutions\ singleton for managing template configuration and precompilation, \FreemarkerDynamicQuerierBuilder\ for processing query parameters and injecting context variables (such as limit, offset, and custom context) into the template environment, and utility classes like \AbstractTemplateMethodModelEx\ for handling parameter extraction and type conversion. The update also introduces template method models (\DynamicTemplateMethodModelEx\) to allow templates to invoke configuration lookups and other dynamic operations.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic/freemarker · high confidence

This change adds the \corant-modules-jpa-hibernate-orm\ module, providing a complete Hibernate-based implementation for the framework's JPA abstraction. It includes a custom \ExtendedHibernateOrmPersistenceProvider\ and \HibernateJPAOrmProvider\ to manage \EntityManagerFactory\ creation, JTA platform configuration, and CDI bean resolution. The module also introduces database-specific dialects for MySQL 5.7, MySQL 8, and SQL Server 2012, along with developer utilities for schema validation and export. Additionally, it implements a Snowflake ID generator for distributed unique identifiers and a session time service to synchronize timestamps with the database.

corant-modules/corant-modules-javafx/corant-modules-javafx-cdi/src/main/java/org/corant/modules/javafx, corant-modules/corant-modules-jpa/corant-modules-jpa-hibernate-orm/src/main/java/org/corant/modules/jpa · high confidence

The JCache module now provides a CDI extension that automatically registers the JCache CachingProvider and produces CacheManager instances, allowing them to be injected directly into application beans. It introduces a custom CorantCacheKeyGenerator that wraps method parameters into a CorantGeneratedCacheKey, enabling consistent cache key handling. The extension also supports an optional global annotation mode (controlled by the corant.jcache.enable-global-annotation property) to activate standard JCache interceptors for caching operations.

corant-modules/corant-modules-jcache/corant-modules-jcache-shared/src/main/java/org/corant/modules/jcache · high confidence

The JMS shared module now includes a complete message receiving and reply implementation. This adds a default message handler that resolves payloads and propagates security contexts, a receiver that manages JMS connections, sessions, and consumers, and a task executor that supports retry logic, circuit breaking, and configurable backoff strategies. A replier component handles sending responses to reply-to destinations or configured reply destinations, preserving correlation IDs and security context. The system is configured via declarative config keys under 'corant.jms' for task delays, pool sizes, and consumer creation permissions.

corant-modules/corant-modules-jms/corant-modules-jms-shared/src/main/java/org/corant/modules/jms/shared/receive · high confidence

The \corant-modules-query-jpql\ module is introduced to provide JPQL-based query capabilities. It adds \AbstractJpqlNamedQueryService\ to handle named query execution, including streaming, forwarding, single-result retrieval, and paging, with support for JPA features like timeouts, flush/lock modes, and native queries. The module includes \DefaultJpqlNamedQuerierResolver\ to manage query builders, supporting both Freemarker and JavaScript script engines for dynamic query generation via \FreemarkerJpqlQuerierBuilder\ and \JavascriptJpqlQuerierBuilder\. Template parameter handling is provided by \JpqlTemplateMethodModelEx\, which was migrated and adapted from the previous SQL query module.

corant-modules/corant-modules-query/corant-modules-query-jpql/src/main/java/org/corant/modules/query/jpql · high confidence

The new corant-modules-json module provides a unified JSON handling layer. It introduces a global Jackson ObjectMapper (Jsons.java) that automatically registers Java 8 time modules, handles SQL dates, and allows customization via the new GlobalObjectMapperConfigurator SPI. Additionally, it adds JSON-B support through JsonbProvider, which produces Jsonb instances configured via the JsonbConfigConfigurator SPI, and includes a JsonConfigSourceResolverImpl for resolving configuration from JSON streams.

corant-modules/corant-modules-json/src/main/java/org/corant/modules/json · high confidence

The DDD shared module now provides a complete Unit of Work implementation backed by JPA and JTA transactions, available in both XA (distributed) and Local Resource (single-database) modes. This change introduces \AggregateEvolutionaryEvent\ and \AggregatePersistedEvent\ to notify listeners of aggregate state changes and persistence outcomes respectively, allowing applications to react to domain events before and after transaction commit. The \AbstractJPAUnitOfWork\ and its managers handle entity manager lifecycle, message dispatching, and saga integration, while the \UnitOfWorkExtension\ enables CDI-based observation of aggregate events, ensuring that domain logic is properly sequenced with transaction boundaries.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared/unitwork · high confidence

Added new classes in the \corant-modules-query-shared\ module to support dynamic query scripting via Java Beans and CDI. \JavaBeanDynamicQuerierBuilder\ provides the builder infrastructure for dynamic queriers, while \JavaBeanScriptProcessor\ implements the \ScriptProcessor\ interface to resolve and execute scripts (such as fetch parameters, predicates, and result injections) by selecting specific CDI beans based on script codes. This enables users to define query behaviors using named CDI beans rather than inline logic.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic/javabean · high confidence

The corant-modules-logging module now provides a Log4j2-based logging implementation. This includes a CDI producer for injecting Log4j2 Logger instances, a provider that configures the application to use Log4j2 as the java.util.logging manager and JBoss logging provider at startup, and utilities to dynamically add or remove Log4j2 appenders.

corant-modules/corant-modules-logging/src/main/java/org/corant/modules/logging · high confidence

The MongoDB query module is now available, providing a new \MgQueryTemplate\ for fluent MongoDB operations (aggregation, filtering, counting) and a named query service (\AbstractMgNamedQueryService\) that resolves queries via Freemarker templates. The implementation includes a \DefaultMgNamedQuerier\ for script execution, a \DefaultMgNamedQuerierResolver\ for managing query builders, and utility classes like \Decimal128Utils\ to handle BSON type conversions (e.g., Decimal128 to BigDecimal) and \MongoDatabases\ for resolving database connections.

corant-modules/corant-modules-query/corant-modules-query-mongodb/src/main/java/org/corant/modules/query/mongodb · high confidence

Added a new JCache (JSR-107) implementation that uses Redisson as the underlying cache store. The \RedissonJCachingProvider\ manages \CacheManager\ instances by resolving a \Redisson\ bean and creating \JCacheManager\ instances, while the \RedissonJCacheExtension\ registers this provider via the Java SPI mechanism, ensuring it is used exclusively if no other caching provider is already configured.

corant-modules/corant-modules-jcache/corant-modules-jcache-redisson/src/main/java/org/corant/modules/jcache · high confidence

This change introduces the \corant-modules-jaxrs-resteasy\ module, providing the integration layer for the Resteasy JAX-RS implementation. It adds a \ResteasyServlet\ that wires into a new \ResteasyHandlerInterceptor\ chain for pre/post request processing, enables Cross-Origin Resource Sharing (CORS) via a configurable \ResteasyCorsProvider\ (controlled by \corant.rs.cors.enable\), and includes a \ResteasyMultiPartCharsetFilter\ to standardize character encoding for multipart form data. Additionally, it provides a \ResteasyResource\ class to handle multipart uploads with improved filename decoding and metadata extraction.

corant-modules/corant-modules-jaxrs/corant-modules-jaxrs-resteasy/src/main/java/org/corant/modules/jaxrs/resteasy · high confidence

The SQL query module is introduced, providing a new infrastructure for executing named SQL queries. This includes the \SqlQueryTemplate\ for direct SQL execution with support for multiple database dialects (MySQL, Oracle, PostgreSQL, SQL Server), and a named query service (\AbstractSqlNamedQueryService\) that resolves and executes queries defined via Freemarker, JavaBeans, or JavaScript templates. The module adds \DefaultQueryRunner\ and \StreamableQueryRunner\ to handle connection management, statement configuration, and result streaming with proper resource cleanup, enabling users to perform standard, paginated, and streaming SQL operations through a unified API.

corant-modules/corant-modules-query/corant-modules-query-sql/src/main/java/org/corant/modules/query/sql · high confidence

This change adds a new Swagger UI module to the Corant DevOps documentation suite, enabling users to browse and interact with the API specifications via a web interface. The implementation includes a JAX-RS application configured at /devops/docs, an OpenAPI extension that initializes the Swagger context, and a REST resource serving the Swagger UI assets from the webjars path. The UI is gated by a configuration property (corant.devops.docs.swagger.openapi.enable) and uses MP-JWT for authentication, providing a standalone layout for API exploration.

corant-devops/corant-devops-docs/corant-devops-docs-swagger · high confidence

The resource handling module has been upgraded with a suite of new classes to support more operations for stream handling. This includes new resource implementations for byte arrays, class paths, file systems, input streams, and NIO paths, along with dedicated loaders for class path and file system resources. Additionally, new stream utilities have been added, such as checksum calculation, byte counting, size limiting, and HTTP range request support, enhancing the flexibility of resource access and manipulation.

corant-shared/src/main/java/org/corant/shared/resource · high confidence

Added the \@DeclarativeQuery\ and \@DeclarativeQueryService\ annotations, along with the \@QueryMethod\ annotation and the \DeclarativeQueryServiceDelegateBean\ runtime implementation. This allows developers to define query service interfaces that are automatically implemented as application-scoped CDI beans, with method names or explicit annotations determining the query execution mode (select, get, page, forward, or stream) and target data source.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/declarative · high confidence

The query module now includes a new dynamic query execution layer in the \corant-modules-query-shared\ package. This adds core interfaces and abstract implementations (\DynamicQuerier\, \AbstractDynamicQuerier\, and their builders) that handle query resolution, result size limiting, offset management, and fetch query processing. Additionally, the \SqlHelper\ utility for parsing SQL structures (such as extracting select columns, order-by clauses, and handling distinct/where patterns) has been moved from the legacy \corant-suites\ module to this new shared location to support the dynamic query logic.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic · high confidence

The \corant-modules-json\ module now includes an experimental JSON expression evaluation engine located in the \expression\ package. This addition introduces a new capability to parse JSON data into an Abstract Syntax Tree (AST) and evaluate it against a context. Key components include \EvaluationContext\ for managing variables and function resolution, \FunctionResolver\ as a Service Provider Interface (SPI) for extending supported functions (prefixed with \\#\), and \SimpleParser\ to handle the conversion of JSON strings or maps into executable expression nodes. This feature is currently in the proof-of-concept (POC) stage.

corant-modules/corant-modules-json/src/main/java/org/corant/modules/json/expression · high confidence

Added a new file-watching subsystem in the \org.corant.shared.resource.watch\ package, providing \DirectoryWatcher\ (using Java NIO WatchService) and \FileWatcher\ (using polling) to monitor file system changes. The package includes event models (\FileChangeEvent\, \PathUpdateEvent\), a listener interface (\FileChangeListener\), and a \Watchers\ utility for launching watchers as daemon threads, enabling applications to react to file creation, modification, and deletion events.

corant-shared/src/main/java/org/corant/shared/resource/watch · high confidence

The query mapping package now includes core model classes (Query, FetchQuery, QueryHint, Script, UnionQuery, Properties) and a SAX-based parser (QueryParseHandler) to define and parse query configurations from XML. This adds support for sub-fetch queries, query hints with SPI integration, script-based predicates and injections, and query properties, while moving ParameterMapping and QueryParser into this module to centralize query definition handling.

corant-modules/corant-modules-query/corant-modules-query-api/src/main/java/org/corant/modules/query/mapping · high confidence

The query module now supports executing scripts to process fetch query parameters, predicates, and injections, allowing for dynamic, script-driven logic in data fetching. This is implemented via new \AbstractCompilableScriptProcessor\ and \DefaultFetchQueryHandler\ classes that compile and cache script functions. Additionally, the \AbstractNamedQueryService\ has been updated to support parallel fetching of multiple related queries when \parentQuerier.parallelFetch()\ is enabled, improving performance for complex data retrieval scenarios.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared · high confidence

Added the \SecuredInterceptor\ and supporting classes (\SecuredInterceptionContext\, \SecuredInterceptorCallback\, \SecuredInterceptorHelper\) to the security shared module. This infrastructure enables the framework to intercept method invocations protected by \@Secured\ annotations, resolve security metadata, and enforce access control checks via \SecurityManager\ before execution.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/interceptor · high confidence

The security-api module now provides the foundational interfaces for the framework's security model. This includes the \SecurityManager\ for login/logout operations, \Authenticator\ and \Authorizer\ for handling authentication and access control checks, and data contracts like \AuthenticationData\, \AuthorizationData\, \Subject\, \Principal\, \Role\, and \Permission\. It also defines \Realm\ for pluggable security providers, \Token\ types (including \UsernamePasswordToken\ and \JsonWebToken\) for credential handling, and specific exception classes (\AuthenticationException\, \AuthorizationException\) to signal security violations. Message bundles for unauthenticated and unauthorized access errors are also included.

corant-modules/corant-modules-security/corant-modules-security-api/src/main/java/org/corant/modules/security · high confidence

The datasource module now includes a shared layer that centralizes datasource configuration via the \DataSourceConfig\ class (under the \corant.datasource\ config root) and manages bean lifecycle through the \AbstractDataSourceExtension\ CDI extension. This extension collects named datasource configurations, registers them with CDI qualifiers, optionally binds them to JNDI, and performs deployment-time connection verification when \verifyDeployment\ is enabled. A new \DBMS\ enum provides automatic detection of database types based on JDBC URLs and driver classes, while \DriverManagerDataSource\ and \JDBCTemplate\ provide shared utilities for creating datasources and executing SQL queries.

corant-modules/corant-modules-datasource/corant-modules-datasource-shared/src/main/java/org/corant/modules/datasource/shared · high confidence

The JPA shared module now supports creating standalone (non-managed) EntityManagers via the new \createStandAloneEntityManager\ method in \PersistenceService\ and \JPAService\. To facilitate customization, two new functional interfaces, \EntityManagerConfigurator\ and \EntityManagerFactoryConfigurator\, have been added, allowing users to apply transformations to EntityManagers and EntityManagerFactories during creation. Additionally, the module introduces \ExtendedEntityManager\ to wrap standard JPA entities with specific lifecycle management (e.g., preventing closure of managed instances) and enhances the \JPAExtension\ CDI extension to validate data source availability and support deployment verification flags.

corant-modules/corant-modules-jpa/corant-modules-jpa-shared/src/main/java/org/corant/modules/jpa/shared · high confidence

The repository layer now supports typed JPA repositories, allowing developers to work with strongly-typed entity access instead of raw queries. This change adds new base classes (AbstractJPARepository, AbstractTypedJPARepository) and interfaces (JPARepository, TypedJPARepository) that provide type-safe methods for finding, merging, and querying entities. A new CDI extension (JPARepositoryExtension) and producer (TypedJPARepositoryProducer) automatically wire these repositories to the correct persistence context and unit of work, enabling injection of typed repositories without manual configuration. The EntityManagers helper class manages persistence context resolution for multiple entity types.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared/repository · high confidence

This change adds the \MgNamedQueryServiceManager\ and the \@MgQuery\ qualifier to the \corant-modules-query-mongodb\ module, enabling CDI-style injection of MongoDB named query services. Users can now inject \MgNamedQueryService\ instances using the \@MgQuery\ annotation, with the target database name specified via the qualifier value or the \corant.query.mongodb.default-qualifier-value\ configuration property. The manager handles service lifecycle, caching, and resource cleanup, while the \@MgQuery\ annotation serves as a named qualifier to distinguish between different MongoDB databases within the application context.

corant-modules/corant-modules-query/corant-modules-query-mongodb/src/main/java/org/corant/modules/query/mongodb/cdi · high confidence

The application now includes a CDI extension (QueryExtension) that automatically discovers and registers beans for interfaces annotated with @DeclarativeQueryService or @DeclarativeQuery. This allows declarative query services to be injected and used without manual bean configuration, with an optional deployment-time verification step controlled by the 'corant.query.verify-deployment' configuration property.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/cdi · high confidence

The corant-config module has been introduced to provide a unified configuration management layer based on the MicroProfile Config specification. This change adds core components including CorantConfig, CorantConfigBuilder, and CorantConfigProviderResolver, enabling the application to retrieve configuration properties from various sources such as system properties, environment variables, and classpath resources. The module supports configuration property expansion using ${property.name} syntax, allows for custom converters, and provides declarative configuration support via ConfigProperties annotations. Additionally, it includes profile-specific configuration handling and expression language processing for dynamic configuration values.

corant-config · high confidence

The query module now supports dynamic queries written in JavaScript. This change introduces the \JavaScriptDynamicQuerierBuilder\ and \JavaScriptProcessor\ components, which leverage the \ScriptEngineService\ to compile and execute JavaScript scripts defined in queries. The processor handles script compilation and caching, and includes logic to pre-compile scripts upon deployment if verification is enabled, allowing users to define query logic using JavaScript.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic/javascript · high confidence

The security module now includes a new \@Secured\ interceptor binding annotation that allows developers to define access control rules (such as allowed roles, deny-all, or run-as identities) on types, methods, and constructors. This is supported by a \SecuredMetadata\ class for processing these annotations and a \SecuredType\ enum distinguishing between role-based and permit-based security. Additionally, a new \@Secure\ stereotype annotation has been introduced for marking security-sensitive components, replacing the previous \@Messages\ stereotype which was removed from this location.

corant-modules/corant-modules-security/corant-modules-security-api/src/main/java/org/corant/modules/security/annotation · high confidence

The Alibaba Cloud module now includes a new \pay\ sub-package containing \AlipayConfig\, which exposes Alipay integration settings (such as server URL, app ID, private key, and certificate paths) via the declarative configuration system under the prefix \corant.cloud.alibaba.pay\.

corant-modules/corant-modules-cloud/corant-modules-cloud-alibaba/src/main/java/org/corant/modules/cloud/alibaba/pay · high confidence

A new CDI extension (MpSmallRyeJWTAuthCDIExtension) has been added to the corant-modules-microprofile-jwt module to automatically register SmallRye JWT beans. This extension detects whether EE Security is available via the corant.security.ee.enable configuration property; if enabled, it registers the JWTHttpAuthenticationMechanism, otherwise it falls back to registering the JAX-RS authentication filter and feature. This allows users to integrate SmallRye JWT authentication into their applications with automatic bean discovery.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-jwt/src/main/java/org/corant/modules/microprofile/jwt/cdi · high confidence

This change introduces new CDI (Contexts and Dependency Injection) support within the corant-modules-jpa-shared module, enabling seamless injection of JPA resources. The new EntityManagerFactoryBean class provides a CDI bean for EntityManagerFactory instances, handling their lifecycle and logging destruction events. Additionally, the JPAInjectionServices class implements Weld's JpaInjectionServices interface to manage injection points for @PersistenceContext and @PersistenceUnit annotations, resolving EntityManager and EntityManagerFactory instances through the PersistenceService. This allows applications using this module to inject JPA components directly via CDI annotations.

corant-modules/corant-modules-jpa/corant-modules-jpa-shared/src/main/java/org/corant/modules/jpa/shared/cdi · high confidence

The SQL query module now includes a CDI (Contexts and Dependency Injection) layer, introducing the \@SqlQuery\ qualifier and the \SqlNamedQueryServiceManager\ to manage named query services. This allows applications to inject SQL query services directly into beans, automatically resolving the target data source and database dialect (defaulting to MySQL) based on the qualifier's configuration. The manager handles service lifecycle and caching, providing a standardized way to access SQL queries within a CDI-enabled environment.

corant-modules/corant-modules-query/corant-modules-query-sql/src/main/java/org/corant/modules/query/sql/cdi · high confidence

The logging module now includes a new LoggerFactory that provides CDI injection for java.util.logging.Logger instances, automatically deriving the logger name from the injection point's declaring class. It also introduces utilities to manage logging handlers across multiple loggers and methods to disable or suppress logging output for both JDK and Log4j2 backends. A new LoggingHandlerAdapter class is added as a no-op handler implementation, and the package metadata has been updated to reflect the current copyright year.

corant-kernel/src/main/java/org/corant/kernel/logging · high confidence

This change introduces the core validation module for the Corant framework, enabling developers to perform bean validation and command validation within a CDI environment. It adds a \DefaultCommandValidator\ that validates command objects using JSR-380 groups, a \CDIMessageSourceBundleLocator\ to integrate Hibernate Validator with the application's message sources for localized error messages, and a \PrioritizedResourceBundleLocator\ for resource loading. The module is configured via \beans.xml\ and MicroProfile config properties to enable the command validator by default.

corant-modules/corant-modules-validation/src/main/java/org/corant/modules/validation · high confidence

The \corant-modules-rpc-feign\ module now provides a CDI-based mechanism to register and configure Feign clients. Developers can annotate interfaces with \@RegisterFeignClient\ to define service-centric views of remote services, specifying configuration options such as base URI, timeouts, and decoders/encoders. The \FeignExtension\ automatically discovers these annotated interfaces and registers them as CDI beans, allowing them to be injected into application components using the \@FeignClient\ qualifier. This replaces previous bootstrap runner patterns with a declarative, container-managed approach for remote service integration.

corant-modules/corant-modules-rpc/corant-modules-rpc-feign/src/main/java/org/corant/modules/rpc · high confidence

The elastic-data module now includes core model classes to support versioned document storage and flexible range queries. A new ElasticVersionedDocument interface extends the base ElasticDocument interface to add version tracking (getVn). Additionally, new embeddable model classes—MixedDateRange, MixedFloatRange, SimpleDateRange, and SimpleFloatRange—provide structured support for date and numeric range operations, allowing users to define and query ranges with start/end boundaries and computed keys.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data/model · high confidence

The \corant-modules-elastic-data\ module now includes new metadata classes to define Elasticsearch index structures. \ElasticMapping\ manages document class associations, version control settings, and parent-child join field logic. \ElasticSetting\ handles index configuration such as shard and replica counts, deriving defaults from annotations. \ElasticIndexing\ serves as the central container that aggregates the index name, settings, mapping schema, and mapping metadata. These classes replace the previous \WebInitParamMetaData\ utility, which has been removed from this package, to provide a dedicated model for Elastic index metadata.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data/metadata · high confidence

The \corant-modules-elastic-data\ module now includes a new \metadata.resolver\ package containing the \ElasticIndexingResolver\ interface and its \AbstractElasticIndexingResolver\ implementation, which parse document class annotations to generate Elasticsearch index metadata and mappings. This change also introduces \ElasticObjectMapper\ for serializing documents to maps using Jackson with Java 8 time support, and \ResolverUtils\ for generating specific field mappings (e.g., keyword, date, geo\_point) from annotations. These classes are newly added to support the elastic data indexing capabilities within the \corant-modules\ structure.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data/metadata/resolver · high confidence

This release introduces two distinct capabilities. First, the \corant-modules-elastic-plugin\ adds a new Elasticsearch plugin providing custom token filters: \mixed\_zh\_en\_ngram\_tf\ for mixed Chinese-English n-gram analysis and \x\_en\_ngram\_tf\ for English n-gram analysis with token retention, registered via \MixedZhEnNGramTokenFilterPlugin\. Second, several Corant modules (\datasource-agroal\, \elastic-data\, \jcache-caffeine\, \jcache-redisson\, \jcache-shared\, \jms-artemis\, \jms-shared\, \jndi\, \jpa-hibernate-orm\, \jpa-shared\) now include \META-INF/services/javax.enterprise.inject.spi.Extension\ files to register their respective CDI extensions (e.g., \AgroalCPDataSourceExtension\, \CaffeineJCacheExtension\, \ArtemisJMSExtension\, \InitialContextExtension\, \JPAExtension\), enabling automatic discovery and initialization of these services in CDI containers. Additionally, \jpa-shared\ includes JPA ORM XML schema files (1.0 and 2.0) for validation.

(repo-wide) · high confidence

The \corant-modules-elastic-data\ module now includes a comprehensive set of Java annotations in the \metadata.annotation\ package to define Elasticsearch field mappings. These new annotations—such as \EsDocument\, \EsKeyword\, \EsDate\, \EsNumeric\, \EsGeoPoint\, \EsNested\, and \EsEmbedded\—allow developers to declaratively specify data types, indexing options, storage settings, and relationship structures (like parent-child or nested) for their entities, replacing the need for manual mapping configuration.

corant-modules/corant-modules-elastic/corant-modules-elastic-data/src/main/java/org/corant/modules/elastic/data/metadata/annotation · high confidence

The \corant-modules-datasource-hikari\ module introduces a new \ExtendedDataSource\ that wraps HikariCP connections to integrate with JTA transactions via \TransactionAwareness\ and \TransactionIntegrator\. The \HikariCPDataSourceExtension\ registers this data source as an application-scoped bean, configuring it through \DataSourceConfig\ and allowing custom tuning via the \HikariCPDataSourceConfigurator\ SPI. Users can enable custom transaction integration to ensure connections are properly associated with and disassociated from the current JTA transaction context.

corant-modules/corant-modules-datasource/corant-modules-datasource-hikari/src/main/java/org/corant/modules/datasource · high confidence

This change introduces a new shared module for JAX-RS resources, providing base classes and helper utilities to simplify REST API development. It includes an AbstractJaxrsResource base class with convenience methods for standard HTTP responses (200, 201, 202, 204) and path resolution. Additionally, it adds a JaxrsExtension CDI extension that automatically discovers and registers JAX-RS providers and resources. The module also introduces StreamResponseBuilder and StreamResponseSlot to facilitate streaming output, including support for HTTP range requests when serving files or input streams.

corant-modules/corant-modules-jaxrs/corant-modules-jaxrs-shared/src/main/java/org/corant/modules/jaxrs · high confidence

This change introduces a new package, \org.corant.modules.jta.narayana.objectstore\, containing a JDBC-backed object store for the Narayana JTA module. It adds \AbstractDomainObjectStore\ as the base implementation of the Narayana \ObjectStoreAPI\, along with two concrete stores: \DomainJDBCStore\ (using \DomainJDBCAccess\) and \DomainDataSourceStore\ (using \DomainDataSourceAccess\), both supporting configurable table prefixes and connection details. A \DomainStoreManager\ bean is also added to manage store lifecycle (e.g., clearing/access finalization). This provides a new mechanism for persisting transaction state to a relational database, replacing or supplementing previous file-based or other store mechanisms within this module.

corant-modules/corant-modules-jta/corant-modules-jta-narayana/src/main/java/org/corant/modules/jta/narayana/objectstore · high confidence

The \corant-modules-jms-api\ module now exposes a rewritten set of JMS interfaces and annotations. Users can configure JMS connections via the new \JMSConfig\ interface and reference standard property names through \JMSNames\. Message sending is controlled by the \@MessageSend\ annotation (supporting delivery mode, time-to-live, and marshaller selection) and the \MessageSender\ interface, which includes a new \GroupMessageSender\ for broadcasting to multiple dispatchers. Message consumption is defined by the \@MessageDriven\ annotation, which introduces configurable retry/back-off strategies (broken back-off algorithm, failure threshold, loop interval) and acknowledgment modes, alongside \@MessageDestination\ for specifying queues/topics and \@MessageContext\ for session acknowledgment settings.

corant-modules/corant-modules-jms/corant-modules-jms-api/src/main/java/org/corant/modules/jms/annotation · high confidence

The JMS API module now includes a new \marshaller\ package containing the \MessageMarshaller\ interface and two concrete implementations: \JavaMessageMarshaller\ for standard Java serialization via \ObjectMessage\, and \ZipBinaryMessageMarshaller\ for compressed binary data via \BytesMessage\. This provides a structured way to serialize and deserialize JMS messages using specific schemas, replacing the previous monolithic or shared-module approach with dedicated, CDI-managed components.

corant-modules/corant-modules-jms/corant-modules-jms-api/src/main/java/org/corant/modules/jms/marshaller · high confidence

The JMS API module now includes a comprehensive set of metadata classes (MessageContextMetaData, MessageDestinationMetaData, MessageDrivenMetaData, MessagePropertyMetaData, MessageReplyMetaData, and MessageSendMetaData) that parse and store configuration derived from JMS annotations. These classes expose specific attributes such as connection factory IDs, destination names, multicast settings, retry backoff strategies, and delivery modes. Additionally, a new MetaDataPropertyResolver interface has been introduced to handle property resolution, supporting variable substitution (e.g., ${var}) and CDI-based injection for externalized configuration.

corant-modules/corant-modules-jms/corant-modules-jms-api/src/main/java/org/corant/modules/jms/metadata · high confidence

This change introduces a new JMS integration layer for the DDD shared module, adding the \AggregateLifecycleMessage\ type to carry aggregate lifecycle events, a \JMSMessageDispatcher\ to handle message serialization and routing to JMS destinations, and supporting interfaces \JMSMessageDestinationResolver\ and \JMSMessagePreDispatchHandler\ to allow custom destination resolution and pre-dispatch property configuration.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared/message · high confidence

The \corant-kernel\ module now exposes a new JMX management bean, \Power\, which implements the \PowerMBean\ interface to allow external monitoring and control of the application's runtime state. This change introduces the ability to check if the Corant kernel is running, as well as to start and stop it via JMX, replacing the previous internal \Manageables\ utility class which is no longer present in the public API.

corant-kernel/src/main/java/org/corant/kernel/jmx · high confidence

The security module now includes a new JOSE (JSON Object Signing and Encryption) implementation in the \corant-modules-security-shared\ library. This adds \JoseProvider\ as a unified entry point for encoding and decoding JWTs, delegating to \JoseSignatureProvider\ (for signing with algorithms like RS256, ES256, HS256) and \JoseEncryptionProvider\ (for encryption with key management algorithms like RSA-OAEP and content encryption algorithms like A256GCM). The \JoseProvider\ supports three protection levels: SIGN, ENCRYPT, and SIGN\_ENCRYPT, allowing users to choose between signed-only, encrypted-only, or combined signed-and-encrypted JWT workflows. The implementation relies on the \jose4j\ library for the underlying cryptographic operations.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/crypto/jose · high confidence

Added a new \metadata\ package to \corant-modules-jpa-shared\ containing classes to parse JPA persistence unit configurations from both MicroProfile Config and \persistence.xml\ files. \PersistencePropertiesParser\ and \PersistenceXmlParser\ extract unit metadata into \PersistenceUnitInfoMetaData\ objects, while \PersistenceSchema\ provides XML schema validation for versions 1.0 through 2.2.

corant-modules/corant-modules-jpa/corant-modules-jpa-shared/src/main/java/org/corant/modules/jpa/shared/metadata · high confidence

The \corant-modules-json\ module now includes new converter factories that enable seamless conversion of JPA \Tuple\ results into Maps or target objects, and precise conversion of \JsonNumber\ instances into various numeric types (such as \Long\, \Integer\, \BigDecimal\, and \BigInteger\). This allows applications using these specific data sources to automatically serialize or transform them into standard Java objects without manual mapping logic.

corant-modules/corant-modules-json/src/main/java/org/corant/modules/json/converter · high confidence

The JSON expression engine now supports a richer set of abstract syntax tree (AST) nodes, including array, object, value, variable, function, return, and comparison nodes. This enables more complex JSON queries and transformations, such as logical operations (AND, OR, NOT, NOR, XOR), comparison operators (equality, inequality, less than, greater than, between, in, not-in, regex), and function calls. Users can now construct more sophisticated JSON expressions for data filtering and manipulation.

corant-modules/corant-modules-json/src/main/java/org/corant/modules/json/expression/ast · high confidence

A new JsonExpressionScriptProcessor has been added to handle query scripts using JSON expressions (JSE type). This component enables dynamic condition judgment and data injection processing for fetch queries, allowing users to define custom logic for filtering and injecting fetched results into parent entities via script-based expressions.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/dynamic/jsonexpression · high confidence

This location introduces the core shared classes for the new corant-modules-jta module, providing a programmatic API for transaction control. It adds a TransactionalAction builder (accessible via TransactionService.actuator()) that allows developers to execute code blocks with explicit transaction types, rollback rules, and timeouts. The update also includes configuration support via TransactionConfig (exposing timeout and auto-recovery settings), a SynchronizationAdapter for easy registration of before/after completion callbacks, and a ChaosXATester utility for simulating transaction failures during testing.

corant-modules/corant-modules-jta/corant-modules-jta-shared/src/main/java/org/corant/modules/jta · high confidence

This change introduces a new Keycloak event listener provider that forwards Keycloak events to a JMS broker. The implementation includes a factory and provider that accept configurable selectors to filter events by type, realm, resource path, and authentication details. It supports both simple predicate-based filtering and complex JSON-based condition matching, allowing administrators to define which Keycloak events are serialized and sent to the configured JMS destination.

corant-modules/corant-modules-keycloak/corant-modules-keycloak-event/src/main/java/org/corant/modules/keycloak · high confidence

The JMS shared module now includes two new message marshaller implementations: KryoMessageMarshaller, which uses Kryo serialization for binary messages, and MapMessageMarshaller, which handles Map-based messages. These classes implement the MessageMarshaller interface and are registered as CDI beans named 'KRYO' and 'MAP' respectively, providing users with additional options for serializing and deserializing JMS messages.

corant-modules/corant-modules-jms/corant-modules-jms-shared/src/main/java/org/corant/modules/jms/shared/marshaller · high confidence

This change introduces a new set of JAX-RS components in the \corant-modules-microprofile-jwt\ module to handle JWT-based authentication and authorization. The \MpJWTAuthJaxRsFeature\ acts as the entry point, enabling JWT processing when a \LoginConfig\ is present. It registers \MpJWTAuthenticationFilter\ to validate bearer tokens and set the security context, \MpJWTAuthorizationFilter\ (via \MpJWTAuthorizationFilterRegistrar\) to enforce \@Secured\, \@RolesAllowed\, and other security annotations, and \MpJWTBlackListFilter\ to handle token revocation. Additionally, \MpJWTHttpAuthenticationMechanism\ provides a CDI-based HTTP authentication mechanism for environments not using the JAX-RS filters directly.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-jwt/src/main/java/org/corant/modules/microprofile/jwt/jaxrs · high confidence

The new \corant-modules-microprofile-restclient\ module provides automatic configuration for MicroProfile REST Clients. It registers a default JSON context resolver (using the project's shared Jackson \ObjectMapper\) for all REST client builders, and allows users to supply custom \MpRestClientBuilderConfigurator\ implementations to apply additional, sorted configuration to the client builder instance.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-restclient/src/main/java/org/corant/modules/microprofile · high confidence

The MongoDB query module now includes a new \Bsons\ utility class that converts Java objects (such as dates, decimals, and ObjectIds) into MongoDB Extended JSON format, alongside a \StringDBRefConverter\ that parses string representations of database references into \DBRef\ objects. These changes are wired into the framework via service provider files and a new \MongoIterableWrapper\ to support standard Java iterables, enhancing how data is serialized and deserialized within the MongoDB query layer.

corant-modules/corant-modules-query/corant-modules-query-mongodb/src/main/java/org/corant/modules/query/mongodb/converter · high confidence

This change introduces the \corant-modules-jta-narayana\ module, providing a new integration with the Narayana JTA implementation. It adds a \NarayanaConfigurator\ interface and a \DefaultNarayanaConfigurator\ implementation that allows users to configure transaction timeouts, node identifiers, object store environments (default, state, communication), and recovery settings (auto-recovery period, backoff) via the \NarayanaTransactionConfig\ properties. The \NarayanaExtension\ handles CDI bean discovery for \UserTransaction\ and \Transaction\, while \NarayanaRecoveryManagerService\ manages automatic or manual JTA recovery processes. Additionally, the existing \NarayanaTransactionServices\ class has been refactored to delegate transaction manager access through a new \NarayanaTransactionService\ bean and includes new utilities for retrieving pending transaction UIDs from the recovery store.

corant-modules/corant-modules-jta/corant-modules-jta-narayana/src/main/java/org/corant/modules/jta/narayana · high confidence

Added a new \ResteasyJaxrsVerticle\ component that enables running JAX-RS applications on the Vert.x platform using the Resteasy framework. This verticle automatically deploys a Corant context, resolves JAX-RS providers and resource classes via CDI, and starts an HTTP server (defaulting to port 8080) to handle requests. It also supports optional configuration of HTTP server options and security domains.

corant-modules/corant-modules-vertx/corant-modules-vertx-jaxrs/src/main/java/org/corant/modules/vertx · high confidence

The corant-modules-websocket module has been introduced to provide Java WebSocket support integrated with the Corant dependency injection framework. It includes a DefaultServerEndpointConfigurator that resolves WebSocket endpoint instances through the application's bean scope, and a WebSocketExtension that automatically discovers classes annotated with @ServerEndpoint via CDI events, enabling seamless injection and management of WebSocket endpoints.

corant-modules/corant-modules-websocket/src/main/java/org/corant/modules/websocket · high confidence

A new XML schema file (nqms\_1\_0.xsd) has been added to define the structure for query mappings. This schema introduces support for defining query parameters, common segments, and individual queries with scripts. It specifically adds a 'fetch-query' element that allows parent queries to call other queries based on their results, including support for predicate scripts to decide execution and injection scripts to process results. The schema also defines parameter type mappings for converting input query parameter values.

corant-modules/corant-modules-query/corant-modules-query-api/src/main/resources/org/corant/modules/query · high confidence

The security module introduces a new provider-based architecture for cryptographic operations, adding a \CipherProvider\ interface and concrete implementations (\JCACipherProvider\, \AsymmetricCipherProvider\, \SymmetricCipherProvider\) along with factory classes. This change enables users to encrypt and decrypt data using a wide range of algorithms, including new support for OSCCA SM3/SM4 ciphers, as well as AES (GCM, CTR, OFB, CBC, PCBC, CFB, ECB), Blowfish, ChaCha20, and DESede. The new API also supports streaming encryption/decryption via \InputStream\ and \OutputStream\ and provides factory presets for various key sizes and modes.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/crypto/cipher · high confidence

The corant-modules-dsa module now includes a suite of new data science capabilities. Users can perform clustering using K-Means (including K-Means++ and Fuzzy variants) and DBSCAN via the new Clusterers utility class, with support for custom distance metrics such as Euclidean, Block, Chebyshev, Cosine, and Minkowski distances. Additionally, the module introduces data structure utilities including a Trie and TrieMap for efficient string operations, and an Ngrams interface for text processing.

corant-modules/corant-modules-dsa/src/main/java/org/corant/modules/dsa · high confidence

This change introduces a set of new default function resolvers for the JSON expression engine, enabling users to perform type conversions, date difference calculations, arithmetic operations, object method/constructor invocations, size checks, and string predicate evaluations directly within expressions.

corant-modules/corant-modules-json/src/main/java/org/corant/modules/json/expression/function · high confidence

Added new accessor classes (AbstractDomainJDBCAccess, DomainDataSourceAccess, DomainJDBCAccess) in the corant-modules-jta-narayana module to support domain-scoped transaction object storage. These classes enable configuration of specific database domains and drivers (MySQL, MSSQL, Oracle, DB2, PostgreSQL) via configuration properties, allowing users to store transaction logs in domain-specific JDBC databases with connection pooling and validation support.

corant-modules/corant-modules-jta/corant-modules-jta-narayana/src/main/java/org/corant/modules/jta/narayana/objectstore/accessor · high confidence

The gRPC module now includes a new \ClientConfig\ class that allows users to declaratively configure gRPC client connection details. This configuration is rooted under the \corant.rpc.grpc\ property prefix and exposes settings for the target \host\, \port\ (defaulting to 9000), and TLS credentials (\certFile\, \keyFile\, \trustManager\). The configuration requires a non-blank host to be considered valid.

corant-modules/corant-modules-rpc/corant-modules-rpc-grpc/src/main/java/org/corant/modules/rpc · high confidence

The bundle module now includes a comprehensive system for managing internationalized messages and exception text. This introduces a CDI-based architecture with a central DefaultMessageResolver that coordinates multiple MessageSource implementations (such as PropertyMessageSource for loading .properties files) and MessageParameterResolvers (which automatically format Enums, Instants, and ZonedDateTimes). The system supports dynamic reloading of message bundles, locale-specific formatting via DefaultMessageInterpreter, and standardized error code handling through GlobalMessageCodes and DefaultExceptionMessageResolver, allowing applications to resolve human-readable, localized messages from keys with parameter substitution.

corant-modules/corant-modules-bundle/src/main/java/org/corant/modules/bundle · high confidence

This change introduces the corant-modules-mail module, providing a new capability for sending emails. It includes a declarative configuration class (MailConfig) bound to the 'corant.mail' prefix for settings like host, port, and credentials, a DefaultMailSender implementation for sending HTML messages with optional CC and attachments, and a MailSenderTemplate for programmatic, one-off mail sending. The module also defines the MailSender interface and a DefaultAuthenticator for handling SMTP authentication.

corant-modules/corant-modules-mail/src/main/java/org/corant/modules/mail · high confidence

The query module now includes a set of new SPI handlers in the shared query package that allow post-processing of query results via XML hints. Users can apply result aggregation (grouping fields into lists), map-reduce operations (projecting fields into nested objects), field type conversion, script-based mapping (JavaScript), and CDI bean-based mapping to transform raw query data before it is returned.

corant-modules/corant-modules-query/corant-modules-query-shared/src/main/java/org/corant/modules/query/shared/spi · high confidence

The \corant-shared\ module now includes a comprehensive retry mechanism in the \org.corant.shared.retry\ package. This new capability provides both \SynchronousRetryer\ and \AsynchronousRetryer\ implementations, allowing users to retry operations with configurable backoff strategies (including exponential, fixed, and various jitter algorithms) and retry strategies (such as max attempts or exception-based classification). The framework supports preconditions to control when retries occur, listeners to monitor retry events, and recovery callbacks to handle final failures.

corant-shared/src/main/java/org/corant/shared/retry · high confidence

The security module now includes a new filter package that adds configurable HTTP security headers (Content-Security-Policy, Referrer-Policy, Strict-Transport-Security, X-Content-Type-Options, X-Frame-Options, and X-XSS-Protection) and content handlers for XSS prevention (HTML, JavaScript, and URI escaping). These filters are applied via a chain of handlers that can be sorted and cached for performance, allowing users to harden their applications against common web vulnerabilities.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/filter · high confidence

The corant-shared module now includes a new service requirement system that allows SPI implementations to be conditionally vetoed based on class presence or configuration values. This introduces the Required interface and SimpleRequired implementation, along with annotations RequiredClassPresent, RequiredClassNotPresent, and RequiredConfiguration. The configuration annotation supports various predicates including regex matching and collection/string containment checks, enabling more flexible conditional service loading.

corant-shared/src/main/java/org/corant/shared/service · high confidence

The security-shared module now includes a new \crypto\ package providing utility classes for managing cryptographic assets. \Certificates.java\ adds capabilities to generate and parse X.509 certificates (including V1 self-signed and V3 CA-signed variants) and decode certificate streams. \Keys.java\ introduces helpers for generating key pairs (RSA, etc.) and secret keys, as well as decoding private, public, and secret keys from PEM-encoded strings or byte arrays. These utilities rely on the Bouncy Castle provider, which is now registered via the new \Providers.java\ class.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/crypto · high confidence

The security module now includes a set of shared base classes and interfaces to standardize authentication and authorization handling. This adds abstract base classes for authentication and authorization that manage pre/post callbacks, a default security context implementation, and simple, serializable implementations for principals, roles, and permissions (including identifiable variants). Additionally, a CDI extension is introduced to automatically register the security interceptor and process security annotations like @Secured, @RolesAllowed, and @DenyAll, enabling declarative security enforcement.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared · high confidence

The ubiquity package now includes a comprehensive set of new utility classes and interfaces to support common development patterns. This includes atomic operations with \Atomics\ (featuring \AtomicDouble\ and singleton initializers), concurrency helpers like \Locks\ (key-based and spin locks) and \Futures\ (simple future implementations), and functional programming aids such as \Throwing\ (wrappers for checked exceptions) and \Mutable\ (mutable wrappers for primitives). Additionally, new interfaces and classes like \Sortable\ (for priority-based sorting), \AttributeSet\ (for attribute management), \Configurator\ (for object configuration), \Immutable\ (builders for immutable collections), \StringTemplate\ (for macro-based string parsing), \ThreadLocals\ (stacks and weak references), and \Tuple\ (multi-element containers) have been introduced to provide reusable, type-safe components for the shared module.

corant-shared/src/main/java/org/corant/shared/ubiquity · high confidence

The \corant-shared/src/main/java/org/corant/shared/util\ package now includes a comprehensive set of new utility classes: \Annotations\ for finding annotations on elements and methods, \Assertions\ for validity checks that throw runtime exceptions, \Bytes\ for primitive-to-byte-array conversions, \Chars\ for character constants and ASCII folding, \Classes\ for class loading and reflection utilities, \Compressors\ for GZIP/ZIP compression, \ContentDispositions\ for parsing HTTP content disposition headers, and \Conversions\ for type conversion helpers. These additions provide foundational tools for common programming tasks within the shared module.

corant-shared/src/main/java/org/corant/shared/util · high confidence

Added Mats and Nets helper classes to the YOLO module. Mats provides static methods to convert float arrays, FloatArrayList, and List\<Float\> into OpenCV Mat objects, and converts OpenCV Mats to Java BufferedImage. Nets provides a method to retrieve output layer names from an OpenCV DNN Net object.

corant-modules/corant-modules-aicv/corant-modules-aicv-yolo/src/main/java/org/corant/modules/aicv · high confidence

The repository has been initialized with essential build and development tooling. A Maven Wrapper (version 3.1.1) is now included for both Unix and Windows environments, ensuring consistent builds without requiring a pre-installed Maven. Standard Eclipse IDE configuration files (code formatter, cleanup, and templates) have been added to enforce consistent code style, alongside .gitignore and .gitattributes files to manage version control hygiene. The README has also been expanded to document the Corant microservice stack, its sub-modules, and getting-started instructions.

(repo-wide) · high confidence

The Agroal and HikariCP datasource implementations have been removed from the application. This change deletes the \AgroalCPDataSourceExtension\ class and its CDI service registration, as well as the \HikariCPDataSourceProducer\ class, effectively eliminating support for these specific connection pool providers within this module.

corant-suites/corant-suites-datasource/corant-suites-datasource-agroal · high confidence

The shared web server module no longer includes the \WebServerBootstrapper\ CDI bean or the \WebServerExtension\ SPI implementation, along with their corresponding service registration file. This removes the automatic discovery and lifecycle management of servlets, filters, and listeners via CDI events, meaning the web server initialization and shutdown handling must now be managed by other components in the application.

corant-suites/corant-suites-webserver/corant-suites-webserver-shared · high confidence

The ConfigSourceLoader class, which previously handled the loading of configuration sources from files and URLs (supporting properties, YAML, JSON, and XML formats), has been removed from the kernel configuration module. This change eliminates the internal utility responsible for parsing and instantiating these specific config source types based on file extensions and classpath resources.

corant-kernel/src/main/java/org/corant/kernel/config · high confidence

The Tomcat-specific web server module has been removed, deleting the \TomcatWebServer\ implementation, its configuration class (\TomcatWebServerConfig\), the \TomcatWebServerConfigurator\ interface, and the associated \Log4j2.xml\ resource. This eliminates the ability to run the application using the Apache Tomcat embedded server within this module.

corant-suites/corant-suites-webserver/corant-suites-webserver-tomcat · high confidence

The Undertow-based web server module has been removed from the product. This change deletes the core implementation classes (\UndertowWebServer\, \UndertowWebServerConfig\, \UndertowWebServerConfigurator\) and associated package metadata that previously handled server startup, configuration (such as IO threads, buffer sizes, and HTTP/2 settings), and deployment management via the Undertow engine. Users relying on this specific Undertow integration will no longer have access to these components.

corant-suites/corant-suites-webserver/corant-suites-webserver-undertow · high confidence

The \WebSocketExtension\ class and its corresponding service provider configuration in \META-INF/services\ have been removed from the \corant-suites-websocket-shared\ module. This change eliminates the automatic discovery of WebSocket server endpoints via CDI annotations, meaning the library no longer provides this specific integration mechanism for users relying on this shared component.

corant-suites/corant-suites-websocket/corant-suites-websocket-shared · high confidence

The \Aggregate\ interface, the \AbstractJpaRepository\ implementation, and the \DefaultContext\ utility class have been removed from the \corant-asosat-ddd\ module. This eliminates the legacy DDD model definitions, the JPA-based repository abstraction, and the static CDI context helper that previously managed event firing and bean resolution.

corant-asosat/corant-asosat-ddd/src/main · high confidence

The \corant-suites-query\ module has removed its legacy XML-based query mapping system and associated execution infrastructure. This includes the deletion of the \QueryMappingService\ and \QueryParseHandler\ (which parsed \nqms\_1\_0.xsd\-defined XML files), the \Query\ and \FetchQuery\ mapping model classes, and the \AbstractSqlNamedQuery\ base class that handled SQL execution, paging, and forward-list logic. Additionally, the \FreemarkerDynamicQueryTpl\ for dynamic query templating and the \CalciteConnectionPools\ utility for managing Calcite database connections have been removed, indicating a shift away from this specific XML-driven and Calcite-integrated query approach.

corant-suites/corant-suites-query · high confidence

The \AbstractDataSourceExtension\ and \DataSourceConfig\ classes in the \corant-suites-datasource-shared\ module have been removed. This eliminates the shared base logic for discovering data source configurations via MicroProfile Config and managing the registry of \DataSource\ instances, indicating that this functionality has been moved or refactored into other modules (such as the newly introduced \corant-context\ module).

corant-suites/corant-suites-datasource/corant-suites-datasource-shared · high confidence

The \corant-modules-jms-api\ module now exposes a new set of interfaces in the \org.corant.modules.jms.receive\ package to define the contract for managed message receiving. This includes \ManagedMessageReceiver\ for lifecycle management (initialize, receive, release), \ManagedMessageReceivingExecutor\ for starting and stopping the receiving process, \ManagedMessageReceivingExecutorConfig\ for configuring pool sizes and delays, \ManagedMessageReceivingHandler\ for processing incoming messages, \ManagedMessageReceiveReplier\ for sending replies, \ManagedMessageReceivingTask\ for cancellable tasks, and \ManagedMessageReceivingExceptionListener\ for handling errors. These interfaces replace the previous implementation-based approach in the shared module, providing a cleaner separation of concerns for JMS message consumption.

corant-modules/corant-modules-jms/corant-modules-jms-api/src/main/java/org/corant/modules/jms/receive · high confidence

The project now includes a Maven Wrapper configuration file (.mvn/wrapper/maven-wrapper.properties) that specifies the use of Apache Maven 3.8.4 and the Maven Wrapper 3.1.1 JAR. This ensures that all developers and CI systems use a consistent, reproducible Maven version without requiring a pre-installed Maven environment.

.mvn · high confidence

This change introduces a new \patch\ package containing custom implementations (\MyLocalXAResource\, \MyConnectableLocalXAResource\, and \MyNarayanaTransactionIntegration\) that replace standard Agroal transaction integration. These classes are designed to resolve an issue where local transactions within a JTA context could not be rolled back properly when a timeout occurred, ensuring that database connections are correctly rolled back in such scenarios.

corant-modules/corant-modules-datasource/corant-modules-datasource-agroal/src/main/java/org/corant/modules/datasource/agroal/patch · high confidence

The corant-modules-bundle now provides standard internationalized error and success messages for both English and Chinese users, covering scenarios such as operation success/failure, system errors, parameter errors, and object serialization issues. To make these messages available, the bundle registers the DefaultExceptionMessageResolver via the Java SPI mechanism and includes the CDI beans.xml configuration.

corant-modules/corant-modules-bundle · high confidence

The Alibaba Cloud module now explicitly registers the OSS client CDI extension via a new META-INF/services file, enabling automatic discovery of the OSS client capabilities. Additionally, the beans.xml configuration file has been moved from the legacy corant-suites-datasource-agroal module to this location, ensuring the module retains its CDI bean discovery mode configuration within the new corant-modules structure.

corant-modules/corant-modules-cloud/corant-modules-cloud-alibaba · high confidence

The archive module in the Maven plugin now uses java.nio.file.Path instead of String to represent archive locations. The Archive interface's getPathName() method is replaced by getPath(), and DefaultArchive stores and resolves paths using Path objects. FileEntry now exposes a getFile() method to access the underlying File object.

corant-devops/corant-devops-maven/corant-devops-maven-plugin/src/main/java/org/corant/devops/maven/plugin/archive · high confidence

The DDD shared module now automatically registers its CDI extensions and conversion factories via Java SPI. Specifically, the JPA repository and unit-of-work extensions are enabled for dependency injection, and the tuple-to-object converter factory is registered to handle data conversion, ensuring these components are discovered without manual configuration.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/resources/META-INF/services · high confidence

The CorantBootHandler SPI now explicitly defines the timing for its lifecycle methods: handleBeforeStart runs before the container starts, handleAfterStarted runs after the container is started (but before the PostCorantReadyEvent is emitted), and handleAfterStopped runs after the container stops. This clarifies when CDI contexts are available and how exceptions in handlers affect subsequent handlers and event emission. Additionally, a new CommandLine utility class has been added to parse command strings and arguments, supporting escaped commas and equals signs for structured input.

corant-kernel/src/main/java/org/corant/kernel/spi · high confidence

The REST client module now includes explicit configuration files to control its behavior: it registers a custom \RestClientBuilderListener\ via the SPI mechanism, enables the propagation of the \Authorization\ header to downstream requests, and sets a low configuration ordinal (-1000) to ensure these settings take precedence over other configurations. Additionally, a \beans.xml\ file is added to enable annotated bean discovery for the module.

corant-modules/corant-modules-microprofile/corant-modules-microprofile-restclient · high confidence

The DDD annotation stereotypes (such as Aggregates, Entities, and DomainServices) have been moved from the \corant.asosat.ddd\ package to \org.corant.modules.ddd.annotation\. This migration includes a behavioral change to the \AggregateType\ qualifier, which now accepts an \Aggregate\ class instead of a string value, and updates the \MessageHandlings\ stereotype to reference the new \MessageHandling\ class. Additionally, the \Queriers\ stereotype has been added to support query operations.

corant-modules/corant-modules-ddd/corant-modules-ddd-api/src/main/java/org/corant/modules/ddd/annotation · high confidence

The core DDD model classes (AbstractAggregate, AbstractEntity, DefaultAggregateAssistant, etc.) have been moved from the corant-asosat-ddd module to the corant-modules-ddd-shared module. This relocation includes refactoring the aggregate lifecycle management to use a new DefaultAggregateLifecycleManager for event-driven persistence, introducing a new Aggregates utility class for simplified aggregate resolution and locking, and adding new interfaces like AggregateReference and EntityReference. The AbstractDefaultAggregate no longer tracks a message sequence number (mn), and AbstractDefaultGenericAggregate now implements Evolvable instead of Enabling/Destroyable, changing how aggregates are enabled and destroyed.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared/model · high confidence

The datasource module now provides improved handling of SQL query results. The row processor has been updated to return maps with case-insensitive keys, ensuring consistent access to column values regardless of database casing. Additionally, new field processors automatically convert BLOB columns to byte arrays and CLOB/NCLOB columns to Strings, simplifying the retrieval of large binary and character data.

corant-modules/corant-modules-datasource/corant-modules-datasource-shared/src/main/java/org/corant/modules/datasource/shared/util · high confidence

The framework's container startup lifecycle now exposes application arguments to event observers. A new asynchronous event, PostCorantReadyAsyncEvent, has been added to signal when the embedded server is ready for service, while the existing PostContainerReadyEvent and PostCorantReadyEvent classes now carry the application arguments passed at startup. Additionally, the internal event emission mechanism has been simplified by removing the embedded CDI emitter class from the CorantLifecycleEvent interface.

corant-kernel/src/main/java/org/corant/kernel/event · high confidence

The jar launcher now correctly preserves the context classloader for ForkJoinPool worker threads, preventing classloading failures when running from a packaged jar. This is achieved by introducing a custom ForkJoinWorkerThread and factory that explicitly set the context classloader upon thread creation.

corant-devops/corant-devops-maven/corant-devops-maven-plugin/src/main/java/bin · high confidence

Added new JAX-RS message body writers (ImprovedJsonStringWriter and ImprovedJsonWebNumberWriter) that wrap the default ResteasyJackson2Provider to handle String and Number types with higher priority. This ensures that JSON strings are properly quoted and numbers are formatted consistently, addressing potential issues with the default RestEasy providers for these specific types.

corant-modules/corant-modules-jaxrs/corant-modules-jaxrs-resteasy/src/main/java/org/corant/modules/jaxrs/resteasy/patch · high confidence

The Jandex Maven plugin now provides clearer feedback during the indexing process. It includes a new debug header to mark the start of indexing, logs an informational message when the index file is built, and adds a safety check that warns and skips indexing if the expected output directory does not exist. Additionally, exception handling was refined to log the full exception object rather than just the message string.

corant-devops/corant-devops-maven/corant-devops-maven-jandex · high confidence

The shared DDD module now provides specific CDI qualifiers to distinguish between transactional resource types: a new @JTAXA annotation marks the use of XA (distributed) resources, while the previous @JPA qualifier has been renamed to @JTARL and repurposed to mark local (non-XA) resources. This change clarifies transactional boundaries for developers using these annotations in their domain models.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared, corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/java/org/corant/modules/ddd/shared/annotation · high confidence

This change introduces the core abstractions for the scripting module, adding the \ScriptEngineService\ interface and \ScriptLang\ enum to the shared package to define a unified contract for script execution. It also establishes the Java ServiceLoader configuration in the JavaScript module, registering both GraalJS and Nashorn implementations to allow the system to discover and use these JavaScript engines.

corant-modules/corant-modules-lang/corant-modules-lang-javascript, corant-modules/corant-modules-lang/corant-modules-lang-shared/src/main/java/org/corant/modules/lang · high confidence

The JMS module now implements the JMSContext injection behavior defined in the Java EE JMSContext Scope Proposals (Option 4). Injected JMSContext objects are automatically managed: they are created and closed per JTA transaction when one is active, or per CDI request scope when no transaction is present. This ensures that beans sharing identical injection annotations within the same transaction or request share the same context, and security context propagation is handled via JMS properties.

corant-modules/corant-modules-jms/corant-modules-jms-shared/src/main/java/org/corant/modules/jms/shared/context · high confidence

The JMS shared module has been restructured to improve service processing and JTA integration. A new AbstractJMSConfig class centralizes JMS connection settings (such as connection factory ID, credentials, and XA flags) using declarative configuration keys. The AbstractJMSExtension now manages JMS metadata, including connection factories, marshallers, and message-driven method validation. A new JMSTransactionIntegration class handles JTA recovery by resolving and managing XAResources for JMS connections. Additionally, the message sending capabilities are now provided by DefaultMessageSender and MessageSenderTemplate, which support various message types, delivery modes, and transactional contexts.

corant-modules/corant-modules-jms/corant-modules-jms-shared/src/main/java/org/corant/modules/jms/shared · high confidence

The JNDI implementation has been moved from the corant-suites module to the new corant-modules module. This relocation includes the core naming context classes (NamingContext, NamingContextEntry), enumeration utilities, and the CDI extension (InitialContextExtension) that registers the InitialContext and BeanManager into JNDI. Existing code referencing the old package path (org.corant.suites.jndi) will need to update imports to the new path (org.corant.modules.jndi).

corant-modules/corant-modules-jndi/src/main/java/org/corant/modules/jndi · high confidence

The Corant kernel entry point has been significantly rewritten, replacing the previous implementation with a new version that integrates standard Java Util Logging, MBean registration/deregistration, and application name resolution. This change alters the internal startup and lifecycle management mechanics, moving away from the prior direct Weld container handling to a more structured approach involving explicit logging and management bean integration.

corant-kernel/src/main/java/org/corant · medium confidence

The \corant-devops-maven-plugin\ packaging logic has been significantly restructured. A new \AttachPackager\ class now handles attaching built artifacts to the Maven project, while a new \DistPackager\ class manages the creation of distribution archives (including lib, app, config, and bin directories) with support for launch scripts and JVM options. The existing \JarPackager\ has been updated to include classes for custom ForkJoinPool worker threads (\JarLauncherForkJoinWorkerThread\, \JarLauncherForkJoinWorkerThreadFactory\) to address context classloader issues. The \PackageMojo\ has been expanded with new configuration parameters such as \groupApp\, \withAttach\, \withUber\, \withDist\, \withJvmOpts\, \useJavaw\, \distFormat\, \useDirectRunner\, \miArgs\, \vmArgs\, and \appArgs\, and now uses \MavenProjectHelper\ for artifact attachment. A new \GlobPatterns\ utility class supports glob-to-regex conversion for file matching, and the \Packager\ interface has been extended with helper methods and constants for directory structures and framework version resolution.

corant-devops/corant-devops-maven/corant-devops-maven-plugin/src/main/java/org/corant/devops/maven/plugin/packaging · high confidence

The package-info.java file has been relocated from the corant-asosat-ddd module to the corant-devops-maven-plugin, specifically under the org.corant.devops.maven.plugin.running package. This change updates the package declaration and module comment to reflect the new location within the DevOps Maven plugin structure.

corant-devops/corant-devops-maven/corant-devops-maven-plugin/src/main/java/org/corant/devops/maven/plugin/running · high confidence

The query module's SPI package now includes new functional interfaces to support advanced query handling: FetchQueryParameterResolver, FetchQueryPredicate, FetchQueryResultInjector, QueryScriptResolver, ResultHintHandler, and ResultHintResolver. The legacy ParameterReviser interface is deprecated in favor of the more capable QueryParameterReviser. Additionally, the Repository interface from the corant-asosat-ddd module has been renamed and refactored into QueryProvider, which now specifically provides a list of Query objects rather than general CRUD operations.

corant-modules/corant-modules-query/corant-modules-query-api/src/main/java/org/corant/modules/query/spi · high confidence

The query module's public API has been reorganized into the \org.corant.modules.query\ package, moving core interfaces and classes such as \QueryService\, \Querier\, \QueryHandler\, \FetchQueryHandler\, and \QueryParameter\ from the previous \corant.suites.query\ location. This change introduces a cleaner separation of concerns with new interfaces like \NamedQuerier\ and \QuerierConfig\, and adds a generic \GenericQueryParameter\ for type-safe query criteria. The \NamedQuery\ interface has been renamed to \NamedQueryService\ to better reflect its role as a service contract. Existing code using these query components will need to update their imports to the new package path.

corant-modules/corant-modules-query/corant-modules-query-api/src/main/java/org/corant/modules/query · high confidence

The SQL dialect layer has been restructured to support more flexible query handling. The core Dialect interface now accepts a hints map for both count and limit SQL generation, allowing for configuration-driven behavior (such as forcing default count SQL). Dialect resolution is now centralized in Dialects.java, which checks for a custom DialectResolver via service discovery before falling back to the built-in dialects (MySQL, Oracle, SQL Server, etc.). Additionally, specific dialects like Oracle and SQL Server 2012 have been updated to use more robust pagination logic (e.g., OFFSET/FETCH NEXT) and improved non-ORDER-BY part extraction.

corant-modules/corant-modules-query/corant-modules-query-sql/src/main/java/org/corant/modules/query/sql/dialect · high confidence

The conversion module in corant-shared has been restructured to support more flexible and ordered type conversions. The central entry point has moved from the Conversions utility class to a new Conversion class, which now handles collection and iterable conversions with improved type resolution. The core Converter and ConverterFactory interfaces now extend Sortable, introducing a priority system that allows multiple converters for the same type pair to be ordered and selected based on preference. Converter composition has been enhanced to support chaining via andThen and compose methods, enabling complex conversions to be built from simpler ones. Additionally, the ConverterHints class has been expanded with new configuration keys for number radix, temporal formatting, and locale settings, and now resolves default values from system properties.

corant-shared/src/main/java/org/corant/shared/conversion · high confidence

The digest module in the security shared library has been restructured to improve code organization and security. New abstract base classes (AbstractHMACProvider, AbstractHashProvider, AbstractPBKDF2Provider, AbstractSignatureProvider) now handle core logic for message authentication, hashing, key derivation, and digital signatures, including timing-safe comparison methods to mitigate brute-force attacks. Factory enums (HMACProviderFactory, HashProviderFactory, PBKFD2ProviderFactory, SignatureProviderFactory) provide standardized, easy-to-use entry points for creating specific algorithm instances (e.g., SM3, SHA-256, PBKDF2WithHmacSHA256, RSA/ECDSA signatures). This change centralizes digest provider creation and enhances security best practices within the shared crypto utilities.

corant-modules/corant-modules-security/corant-modules-security-shared/src/main/java/org/corant/modules/security/shared/crypto/digest · high confidence

The exception package has been restructured to improve localization and reduce coupling. A new \ExceptionMessageResolver\ interface and its \SimpleExceptionMessageResolver\ implementation now handle localized message retrieval from classpath properties, replacing the previous CDI-dependent \GeneralRuntimeExceptionMessager\ approach. \GeneralRuntimeException\ has been updated to use this new resolver via \getMessageKey()\ and \getMessageParameters()\, while \CorantRuntimeException\ serves as the new base class for framework exceptions (with \NotSupportedException\ now extending it directly instead of \GeneralRuntimeException\). Additionally, \GeneralExceptionSeverity\ fields are now final, and \GeneralRuntimeExceptionWrapper\ logic remains for chaining exception modifications.

corant-shared/src/main/java/org/corant/shared/exception · high confidence

The kernel boot package has been renamed from \org.corant.kernel.bootstrap\ to \org.corant.kernel.boot\, moving classes like \DebugRunner\ and \package-info\ to this new location. A new \DirectRunner\ class has been added to handle application lifecycle commands (start, stop, restart, shutdown) using shared memory (MMF IPC), allowing for process control via command-line arguments. The \DebugRunner\ implementation was updated to use \Launches.debugForkAs()\ instead of the previous utility method.

corant-kernel/src/main/java/org/corant/kernel/boot · high confidence

The \corant-shared\ module's \normal\ package has been updated to support more granular configuration and runtime identification. A new \Defaults\ interface was added to centralize common constants (such as charset and buffer sizes) and provide a \getCorantVersion\ method that attempts to read the version from the JAR manifest or Maven \pom.properties\. The \Names\ interface was expanded to include namespace splitting utilities, new configuration keys (including sensitive data handling and persistence unit names), and updated JNDI constants. Additionally, the \Priorities\ interface now defines explicit ordinal ranges for application, framework, and module layers, and adds specific ordinals for system environment and properties, allowing for more precise configuration loading order.

corant-shared/src/main/java/org/corant/shared/normal · high confidence

The MicroProfile Config service provider file has been removed, eliminating the registration of ApplicationConfigSourceProvider and ApplicationProfileConfigSourceProvider. Additionally, the beans.xml file has been updated to use Unix line endings, though its configuration content remains unchanged.

corant-kernel/src/main/resources · high confidence

The file registering the Narayana transaction service implementation for the Weld container (org.jboss.weld.bootstrap.api.Service) has been removed. This means the custom NarayanaTransactionServices provider is no longer automatically discovered or registered by the CDI container in this module.

corant-suites/corant-suites-jta/corant-suites-jta-narayana · high confidence

The CharacterEncodingFilter and AbstractCorsFilter have been moved from the corant-suites module to the new corant-modules-servlet module. This migration includes a behavioral change to the configuration property names: CORS settings now use the prefix 'corant.servlet.cors' instead of 'cors', and the enable flag is now 'corant.servlet.cors.enable' (previously 'cors.enabled'). Additionally, default values for CORS settings have been updated, such as the origin defaulting to '\*' and methods defaulting to 'GET, POST, OPTIONS'. The CharacterEncodingFilter is a new addition that allows configuring request and response character encodings via 'corant.servlet.request-charset-filter' and 'corant.servlet.response-charset-filter' properties.

corant-modules/corant-modules-servlet/src/main/java/org/corant/modules/servlet/filter · high confidence

The servlet metadata classes (MultipartConfigMetaData, WebInitParamMetaData, HttpConstraintMetaData, HttpMethodConstraintMetaData, ServletSecurityMetaData, WebFilterMetaData, WebListenerMetaData, and WebServletMetaData) have been relocated from the corant-suites module to the corant-modules module. In addition to the package rename, several classes now return defensive copies of internal arrays (e.g., rolesAllowed, httpMethodConstraints) to prevent external mutation, and WebInitParamMetaData now processes values through Configs.assemblyStringConfigProperty, which may alter configuration values at runtime.

corant-modules/corant-modules-servlet/src/main/java/org/corant/modules/servlet/metadata · high confidence

The beans.xml configuration in the DDD shared module has been moved from the JNDI suite and updated to use bean-discovery-mode="annotated" instead of "all", which restricts CDI bean discovery to only those classes explicitly annotated. Additionally, new localization files (English and Chinese) have been added to define specific error messages for domain aggregate lifecycle issues, unit of work transaction errors, and identifier construction failures, ensuring users receive clear, localized feedback when these DDD-specific constraints are violated.

corant-modules/corant-modules-ddd/corant-modules-ddd-shared/src/main/resources/META-INF · high confidence

The web server shared components, including the WebServer interface, AbstractWebServer implementation, WebServerConfig, and the new WebServerBootstrapper and WebServerHandlers, have been moved from the corant-suites module to the new corant-modules module. This change updates the package namespace from org.corant.suites.webserver to org.corant.modules.webserver, reflecting the structural reorganization of the framework's modules.

corant-modules/corant-modules-webserver/corant-modules-webserver-shared/src/main/java/org/corant/modules/webserver · high confidence

Added YOLO vehicle recognition demo applications; Added tests for BSON serialization and JSON expression evaluation; Added tests for HTTP range request parsing and stream handling; Added unit test infrastructure for web server integration; Added unit tests for atomic, mutable, and tuple utilities; Added unit tests for shared security crypto providers; Added unit tests for shared utility classes; Enhanced JUnit 4 test runner with advanced configuration and lifecycle hooks; Removed legacy JUnit 4 integration tests and associated configuration.

The project introduces a comprehensive set of new Maven module definitions under the \corant-modules\ hierarchy, establishing the build structure for a wide range of capabilities including configuration (\corant-config\), context management (\corant-context\), cloud integrations (Alibaba, Tencent), data sources (DBCP, Hikari), Domain-Driven Design (DDD) APIs, Elasticsearch, Flyway, JavaFX, JAX-RS (Resteasy), caching (Caffeine, Redisson), JMS (Artemis), JPA (Hibernate ORM/OGM), JSON processing, and JTA. These POM files define the dependency graph for these new modules, relying on shared internal artifacts and standard Jakarta EE APIs.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 50.

• Code Health 86
• Architecture 97
• Maturity 43
• Readiness 63
• Security 40

• 300 commits — 268 feature/other, 32 fixes

• corant-modules/corant-modules-query — 35 commits
• corant-shared/src — 34 commits
• corant-modules/corant-modules-security — 29 commits
• corant-boms/pom.xml — 27 commits
• (root) — 21 commits
• corant-modules/corant-modules-ddd — 19 commits
• .github/workflows — 14 commits
• corant-modules/corant-modules-microprofile — 14 commits
• corant-context/src — 13 commits
• corant-modules/corant-modules-json — 13 commits
• corant-modules/corant-modules-bundle — 9 commits
• corant-modules/corant-modules-javafx — 8 commits
• corant-modules/corant-modules-jaxrs — 8 commits
• corant-modules/corant-modules-vertx — 8 commits
• corant-modules/corant-modules-datasource — 6 commits
• (repo) — 5 commits
• corant-config/src — 5 commits
• corant-modules/corant-modules-jpa — 4 commits
• corant-devops/corant-devops-docs — 3 commits
• corant-modules/corant-modules-jms — 3 commits

• fix: Extract nested query parameter classes to a new file to avoid OpenJDK BUG JDK-8167433
• fix: Fix ForkJoinPool worker thread context classloader issue when using jar launcher.
• fix: Fix JPA verify deployment issue.
• fix: Fix JSE expression default function resolve issue
• fix: Fix Methods issues, introduce new JSON expression AST node type
• fix: Fix WWW-Authenticate header issues.
• fix: Fix bug
• fix: Fix cipher issues, upgrade dependencies.
• fix: Fix class path relative resource lookup issue.
• fix: Fix date/time conversion pattern
• fix: Fix dynamic query limit NPE issue.
• fix: Fix empty array template method issues
• fix: Fix fetch query issues, supports uniform query service.
• fix: Fix generic query parameter offset setting bug
• fix: Fix issues
• fix: Fix log4j add appender issues.
• fix: Fix mongo distinct & count query issues
• fix: Fix query parameter variable handling issue.
• fix: Fix row processor issue.
• fix: Fix security annotation processing issues
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

finesoft/corantce was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.