Ahoo-Wang/Wow

This system is a comprehensive event-driven framework for building microservices, featuring a dual-layer architecture that manages both domain events and state events. It provides a robust command processing pipeline with built-in compensation logic for handling failures and retries, alongside a reactive query layer for efficient data retrieval. The framework includes a modernized React-based dashboard for monitoring and managing these states, supported by a configurable server that handles scheduling, webhooks, and Kubernetes deployment.

148 changes.

This period focused on modernizing the framework's core with a Kotlin-first approach, replacing Java reflection with Kotlin reflection and introducing new interfaces for ownership, space, and state management. The architecture was significantly refactored to support multi-tenancy, command result tracking, and state event handling, while also adding new storage backends like Redis, Elasticsearch, and ClickHouse.

62 changes.

This period focused on introducing a comprehensive query API with fluent DSL support and refactoring the internal dispatcher and command handling architectures. Concurrently, the compensation dashboard was migrated from Angular to React, adding new features for managing failed executions and improving the overall testing coverage.

25 changes.

This period focused on enhancing core performance through a new fast-path function invoker using MethodHandle optimization and establishing a comprehensive JMH benchmarking suite. Concurrently, the project significantly expanded test coverage by introducing contract tests for critical components like the command bus, event store, and function invokers, while also adding unit tests for scheduler and metadata handling.

A new Spring Boot application class, CompensationServer, has been added to the compensation module. This file serves as the main entry point for running the compensation service, configuring the application context to scan the relevant bounded context and service components.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server · high confidence

The wow-benchmarks/docker area now includes dedicated Docker Compose profiles to spin up Redis and MongoDB instances for benchmarking. A new benchmark.env file defines environment variables for both databases, while compose.redis.yml and compose.mongo.yml provide the service definitions, including health checks, resource limits, and logging configurations. Additionally, a redis.conf file is added to tune Redis performance for local benchmark runs.

wow-benchmarks/docker · high confidence

This change introduces the core implementation for storing and querying domain events and snapshots using Elasticsearch. It adds \ElasticsearchEventStore\ and \ElasticsearchSnapshotStore\ to handle event and snapshot persistence, along with \ElasticsearchEventStreamQueryService\ and \ElasticsearchSnapshotQueryService\ to support rich querying capabilities. The update also includes index name conversion logic, template initialization, and condition/sort/projection converters to map internal query structures to Elasticsearch queries.

wow-elasticsearch · high confidence

The compensation dashboard now includes a new Failed details view that displays comprehensive information about failed executions. The view shows basic execution details (ID, status, execution time, recoverability, and retryability) using Ant Design components, alongside function metadata (context, processor, function name and kind) and event identifiers (context, aggregate, event ID, version, tenant ID, and aggregate ID). It also displays retry state information including the number of retries, retry schedule, and next retry time. Additionally, an ErrorDetails component renders the error stack trace in a read-only Monaco editor with fullscreen capability.

compensation/dashboard/src/features/Failed/details · high confidence

A new \FunctionAccessor\ interface and \SimpleFunctionAccessor\ implementation have been added to the \wow-core\ module, enabling type-safe reflection-based invocation of Kotlin functions. This includes support for member functions, extension functions, and static extension functions, with automatic accessibility handling and integration with the existing \FunctionInvoker\ infrastructure.

wow-core/src/main/kotlin/me/ahoo/wow/infra/accessor/function · high confidence

The example/transfer location now includes a complete Java-based domain-driven design example for a bank account transfer scenario. This adds a new README.md documenting the Saga-based transfer flow (Prepare, CheckBalance, LockAmount, Entry, Confirm) and the associated Java classes (AccountState, Account, TransferSaga). Additionally, a Transfer.http file is introduced to provide executable API tests for the transfer endpoints, allowing users to verify the behavior of the example server.

example/transfer · medium confidence

The compensation service is now deployable on Kubernetes with a new set of configuration files. This includes a deployment manifest that sets the service to 1 replica with specific resource limits (4 CPU, 2560Mi memory) and Java options, alongside a HorizontalPodAutoscaler for scaling. Configuration is split across three ConfigMaps: a base config, an Elasticsearch-specific config, and a combined Redis/Elasticsearch config, allowing flexible storage backends. Additionally, an init script is provided to create hashed indexes and enable sharding on the \compensation\_db\ MongoDB database, and a NodePort service is exposed on port 32765.

deploy/compensation · medium confidence

A new ProcessorInfo interface has been introduced in the wow-api module to define metadata for message processors. This interface, located at me.ahoo.wow.api.messaging.processor, extends NamedBoundedContext and exposes a processorName property, enabling the system to identify and route messages based on processor identity within a bounded context.

wow-api/src/main/kotlin/me/ahoo/wow/api/messaging/processor · high confidence

Adds Redis implementations for the command bus, domain event bus, and state event bus, along with an event store and snapshot store backed by Redis. The change introduces a shared \AbstractRedisMessageBus\ base class, topic converters for routing messages to Redis streams, and Lua scripts for atomic operations. Integration and unit tests are added to verify the new Redis components.

wow-redis · high confidence

The compensation dashboard now includes a new Failed view that allows users to search, view, and manage failed execution states. This includes a search panel for filtering by ID, event, and aggregate details, a table displaying execution failures with options to view details, change function parameters, apply retry specifications, and mark recoverable states. The implementation uses the fetcher-react library for handling promise-based state management and loading states for all actions.

compensation/dashboard/src/features/Failed · high confidence

New service files are introduced to the compensation dashboard, including a fetcher configuration, a CoSec security configurer, and client wrappers for execution failed commands and queries. A test file verifies that the service index correctly exports these new clients.

compensation/dashboard/src/services · high confidence

Users can now receive WeChat bot notifications for compensation events (execution failed, success, prepared, and recoverable marked) via a new \WeiXinWebHook\ component. This integration is conditionally loaded only when the \wow.compensation.webhook.weixin.url\ property is set, allowing users to enable WeChat notifications without affecting the default behavior. The feature uses the \CoApi\ interface to interact with the WeChat bot API, supporting markdown message templates for event details.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/webhook/weixin · high confidence

The compensation server now includes a new scheduler component that automatically retries failed compensation tasks. This scheduler is fully configurable via properties (batch size, delay, period) and can be disabled entirely by setting the associated property to false, giving users control over whether the background retry mechanism is active.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/scheduler · high confidence

New mock implementations, DelayEventStore and DelaySnapshotStore, have been added to the test/wow-mock module. These classes wrap the standard InMemoryEventStore and InMemorySnapshotStore, introducing a configurable artificial delay to all operations. This allows testing scenarios that require simulating latency or slow responses from the underlying storage systems.

test/wow-mock/src/main · high confidence

The example transfer server now includes a Spring Boot application entry point and configuration files that set up in-memory message buses, in-memory state and snapshot storage, and expose health and custom 'wow' and 'wowBI' actuator endpoints. This provides a self-contained example of the transfer service with debug logging for 'me.ahoo.wow' and manual machine ID configuration for the ID generator.

example/transfer/example-transfer-server · high confidence

Added new Kubernetes deployment and configuration files for the performance test example. This includes a \deployment.yaml\ for the \wow-example\ service, along with Helm value files for Kafka, MongoDB, Redis, and Zookeeper to support the performance testing environment. A JavaScript script (\mongo\_sharding.js\) is also included to configure MongoDB sharding for the example database.

deploy/example/perf · high confidence

A new \ConcurrentManySink\ class has been added to wrap reactive sinks with \ReentrantLock\ to ensure thread-safe, serialized emission of events, preventing serialization errors in concurrent scenarios. This change also includes utility extensions for \Scannable\ to check cancellation and termination states.

wow-core/src/main/kotlin/me/ahoo/wow/infra/sink · high confidence

A new SQL script at deploy/script/clickhouse.sql defines the ClickHouse tables and Kafka materialized views required to sync order state and command data. The script creates local and distributed tables for order state (including fields like firstOperator and firstEventTime), order state last (using a sipHash64 partition to prevent merge failures), and order command data, along with the corresponding Kafka queues and consumer views.

deploy/script · high confidence

A new \wow-benchmarks\ module has been introduced, containing a comprehensive set of JMH benchmarks for the Wow framework. These benchmarks cover critical performance areas including component initialization, command pipeline processing, event publishing, serialization, and end-to-end command write scenarios. The suite includes specific tests for accessor components, aggregate handling, idempotency checks, and MongoDB document serialization, providing a baseline for measuring performance improvements in these core subsystems.

wow-benchmarks/src · high confidence

A new \scripts/skill\_lint.py\ tool and its corresponding \scripts/test\_skill\_lint.py\ tests have been added to the repository. This script automatically scans the \skills/\ directory for common documentation drift and anti-patterns, including: using \rg\ instead of \Grep\/\Glob\, using resolved Gradle module placeholders, using Wow Query DSL, avoiding legacy headers like \Command-Wait-Timout\, and ensuring local markdown references exist. The tests verify that the linter correctly identifies these issues and allows valid patterns.

scripts · high confidence

A new aggregate class, DisabledRouteAggregate, has been added to the example domain. This class is annotated with @AggregateRoute(enabled = false), indicating that this specific route is intentionally disabled or excluded from active routing within the application's domain model.

example/example-domain/src/main/kotlin/me/ahoo/wow/example/domain/disable · high confidence

New example HTTP request files (AddCartItem.http, CreateOrder.http) and an environment configuration (http-client.env.json) have been added to the deploy/example/request directory. These files provide ready-to-use templates for testing cart and order endpoints, including headers for command wait stages and timeouts, as well as sample JSON payloads for adding items to a cart and creating an order.

deploy/example/request · high confidence

The example-transfer-api module now includes a full set of Java API records for the transfer domain, including CreateAccount, Confirm, Entry, EntryFailed, FreezeAccount, LockAmount, Prepare, Prepared, UnfreezeAccount, UnlockAmount, and AmountLocked/Unlocked. The TransferService interface defines the bounded context and aggregate scope, while the new records provide the command and event structures for account management and fund operations.

example/transfer/example-transfer-api · high confidence

Added new Java files for the transfer example domain, including the Account aggregate root with command handlers for creating, locking, entering, confirming, freezing, and unfreezing accounts, along with its corresponding state class. Also added a TransferSaga to coordinate the transfer flow and a TransferBoundedContext configuration.

example/transfer/example-transfer-domain/src/main · high confidence

The wow-opentelemetry module now provides comprehensive distributed tracing support for the framework's core messaging and state management components. Users can enable automatic OpenTelemetry instrumentation for local and distributed command buses, domain event buses, state event buses, event stores, and snapshot stores by applying the \.tracing()\ extension. This change introduces new \Tracing\*\ wrapper classes (e.g., \TracingLocalCommandBus\, \TracingEventStore\, \TracingSnapshotStore\) that wrap existing implementations to capture span data. Additionally, the \CommandGateway\ and \WaitStrategy\ are now instrumented to track command execution and waiting periods. The update also includes contract and unit tests to verify trace ID propagation and span creation for these components.

wow-opentelemetry · high confidence

The project introduces a new Gradle-based benchmarking framework, defined in \wow-benchmarks/gradle/benchmarking.gradle.kts\, which configures various run profiles (smoke, quick, full) with specific warmup, measurement, and profiling settings for JMH benchmarks. Additionally, \wow-benchmarks/gradle/jmh-packaging.gradle.kts\ adds a new JMH packaging task that merges \wow-metadata.json\ files and SPI service files from the runtime classpath into the final JMH JAR, ensuring that metadata and service providers are correctly aggregated for benchmark execution.

wow-benchmarks/gradle · high confidence

The wow-bi module now includes a new capability to automatically generate ETL sync scripts for ClickHouse. This introduces a \BiScriptGenerator\ that produces SQL statements and manages the lifecycle of BI deployments, including support for standalone and cluster topologies, Kafka-based offset storage, and idempotent deployment operations. The system inspects the existing ClickHouse catalog to validate consistency and generate scripts that handle state, commands, and expansion plans. Integration tests verify the generation of DDL, data flow from Kafka, and cluster replication behavior.

wow-bi · medium confidence

The example server now exposes a new CartController that provides REST endpoints for retrieving the current user's cart state (both async and sync), sending a custom command, and adding items to the cart via a streaming response. Additionally, a MountedCommandRewriter service is introduced to handle rewriting of MountedCommand builders.

example/example-server/src/main/kotlin/me/ahoo/wow/example/server/cart · medium confidence

The compensation dashboard has been rebuilt using React, replacing the previous implementation. This includes a new entry point (main.tsx) that renders the application using React 18's createRoot, integrates Ant Design's App component, and sets up routing via react-router. The migration introduces Monaco Editor configuration (monacoConfig.ts) for code editing capabilities and establishes a comprehensive test suite (main.test.tsx, setupTests.ts) using Vitest and React Testing Library to verify rendering and error handling.

compensation/dashboard/src · high confidence

The compiler now automatically generates an \AggregatesMetadata\ file containing metadata for all defined aggregates, and generates \\*Properties\ files containing navigation constants for state aggregates. This enables the runtime to resolve aggregate relationships and query structures at compile time, reducing the need for manual configuration or reflection-based discovery.

wow-compiler/src/main/kotlin/me/ahoo/wow/compiler/query · high confidence

The compensation dashboard now uses separate environment configuration files to define the API base URL. In development, the dashboard connects to the local Kubernetes service (http://compensation-service.dev.svc.cluster.local/), while in production it uses a relative path (/) for API calls. This allows the frontend to correctly route requests to the appropriate backend service depending on the deployment environment.

compensation/dashboard · high confidence

The framework now automatically discovers and registers message propagation implementations and Jackson serialization modules via Java ServiceLoader. Specifically, the new \MessagePropagator\ service file registers \WaitPlanMessagePropagator\, \CommandOperatorMessagePropagator\, \TraceMessagePropagator\, and \CommandRequestHeaderPropagator\ to support message tracing and command header propagation. Additionally, the \WowModule\ is registered as a Jackson module, enabling automatic serialization support for Wow's domain objects.

wow-core/src/main/resources/META-INF/services · high confidence

The command message model has been expanded to support multi-tenant isolation and idempotent command processing. \CommandMessage\ now implements \OwnerId\ and \SpaceIdCapable\ to enable namespace-based data isolation and ownership tracking. A new \CommandResultAccessor\ interface has been introduced to allow storing and retrieving command execution results, facilitating idempotency and auditing. Additionally, \CommandMessage\ now supports void commands via an \isVoid\ property, and the \RequestId\ interface has been updated with improved documentation. These changes provide a more robust foundation for distributed command handling and state management.

wow-api/src/main/kotlin/me/ahoo/wow/api/command · high confidence

The messaging API introduces a new TopicKind enum and TopicKindCapable interface to categorize topics by purpose (COMMAND, EVENT\_STREAM, STATE\_EVENT, UNDEFINED). The Header interface now extends Copyable and supports read-only mode via withReadOnly(), preventing illegal writes after finalization. The Message interface adds CreateTimeCapable, exposes createTime, and provides fluent withHeader() methods for metadata manipulation.

wow-api/src/main/kotlin/me/ahoo/wow/api/messaging · high confidence

The event sourcing core now supports routing events to specific stores via \RoutingEventStore\ and \AggregateEventStoreRegistry\, enabling multi-tenant or sharded event storage. A new \AggregateIdScanner\ interface and implementation allow scanning aggregate IDs by name, improving performance for aggregate discovery. Additionally, the \EventStore\ interface and its implementations (\InMemoryEventStore\, \AbstractEventStore\) now support loading event streams by event time range, not just by version. The \EventSourcingStateAggregateRepository\ has been updated to support loading state aggregates by event time, and a new \EventStoreStateAggregateRepository\ provides direct event-sourcing without snapshots. Request ID existence checking is now a first-class operation on the \EventStore\ interface, with a \RequestIdExistenceChecker\ interface and \NoopRequestIdExistenceChecker\ implementation added to handle idempotency checks authoritatively.

wow-core/src/main/kotlin/me/ahoo/wow/eventsourcing · high confidence

The compensation dashboard now includes generated TypeScript code for the \execution\_failed\ aggregate, providing command and query clients along with associated types. This adds support for managing execution failures, including operations to apply execution states, retry specifications, and function changes, as well as querying domain events and aggregate states.

compensation/dashboard/src/generated · high confidence

A new AggregateSchedulerSupplier interface and its DefaultAggregateSchedulerSupplier implementation have been added to the wow-core module. This change provides a mechanism to obtain or create Reactor schedulers specifically for aggregate operations, supporting graceful stopping and parallelism configuration. The default implementation caches schedulers per aggregate, ensuring consistent thread allocation and resource reuse, which improves performance by reusing schedulers for the same aggregate operations.

wow-core/src/main/kotlin/me/ahoo/wow/scheduler · high confidence

The framework now provides base interfaces for modeling awareness. A new \Aware\ interface is added to \me.ahoo.wow.api.modeling.aware\, and a \VersionAware\ interface is introduced that extends it, allowing components to expose a version number. This refactors and moves these definitions from the example project into the core API.

wow-api/src/main/kotlin/me/ahoo/wow/api/modeling/aware · medium confidence

The wow-cosec module is introduced to provide security enhancements, including a new \CoSecMessagePropagator\ that propagates \app\_id\ and \device\_id\ headers across messages, a \CoSecCommandRequestHeaderAppender\ that extracts these headers into command headers, a \CoSecCommandBuilderExtractor\ that pulls \request\_id\ and \space\_id\ from requests, and a \CoSecRewriteRequestCondition\ that rewrites query conditions based on the space ID. These components are wired via the \MessagePropagator\ service provider file.

wow-cosec · high confidence

A new functional interface, CommandValidator, has been added to the API layer, allowing commands to implement custom validation logic before execution. This enables developers to define business rules and constraints on command payloads, ensuring data consistency and preventing invalid state changes early in the command processing pipeline.

wow-api/src/main/kotlin/me/ahoo/wow/api/command/validation · high confidence

The API module adds the Copyable interface, allowing objects to create deep copies, and the Ordered interface, which provides an ordering value for sorting and prioritization. The Version interface is updated with new computed properties (initialized, isInitialVersion) and Jackson annotations to exclude them from JSON serialization. The Identifier interface is also modified to extend StringIdCapable.

wow-api/src/main/kotlin/me/ahoo/wow/api · medium confidence

A new ExampleService object is added to the example-api module, defining a BoundedContext named 'example-service' (alias 'example') that aggregates 'order' and 'cart' aggregates. The cart aggregate is configured with a static default tenant ID, while the order aggregate does not specify a tenant ID. This change establishes the foundational context and aggregate mappings for the example application.

example/example-api/src/main/kotlin/me/ahoo/wow/example/api · high confidence

The messaging system now exposes a new \FunctionInfo\ API to provide complete metadata about functions that process messages. This includes the \FunctionInfo\ interface and its \FunctionInfoData\ implementation, which combine function naming and identification with function kind classification (COMMAND, SOURCING, EVENT, STATE\_EVENT, ERROR) for precise routing and invocation. The \FunctionKind\ enum maps each function type to a corresponding \TopicKind\ for message routing consistency. Additionally, \NamedFunctionInfo\ and \NamedFunctionInfoData\ provide named function information with processor context, while \FunctionNameCapable\ (renamed from \AggregateMetadata\) exposes the function name for identification and routing purposes.

wow-api/src/main/kotlin/me/ahoo/wow/api/messaging/function · high confidence

Adds a new \wow-models\ module containing common capability interfaces such as \CompletedCapable\, \ReasonCapable\, \RemarkCapable\, \TypeCapable\, \ItemIdCapable\, \QuantityCapable\, \StatusCapable\, and \TenantAwareIdCapable\. Additionally, it introduces a comprehensive tree model infrastructure, including the \TreeCoded\ interface, \Info\ and \Flat\ interfaces, and aggregate-level support via \Tree\ and \TreeState\ classes, along with corresponding command and event definitions for creating, updating, deleting, and moving tree nodes.

wow-models · high confidence

The \wow-compensation-api\ module now includes the foundational API contracts for the compensation feature. This includes the \CompensationService\ definition and a set of new data classes for managing execution states: \CreateExecutionFailed\ and \ExecutionFailedCreated\ for initial failure recording; \ApplyExecutionFailed\ and \ApplyExecutionSuccess\ for state updates; \ApplyRetrySpec\ and \RetrySpec\ for configuring retry policies; \ChangeFunction\ for function metadata updates; and \MarkRecoverable\ for handling recoverable errors. These classes define the structure for tracking, retrying, and managing failed executions within the system.

compensation/wow-compensation-api/src/main · high confidence

The compensation module now includes the core domain models for tracking failed executions, including the \ExecutionFailed\ aggregate root and its state, which manage the lifecycle of failed operations and their retry attempts. A new \NextRetryAtCalculator\ is introduced to compute the next scheduled retry time using an exponential backoff strategy. Additionally, a \FindNextRetry\ interface is provided to query for pending retries, enabling the system to identify and process failed executions that are due for retry.

compensation/wow-compensation-domain/src/main · high confidence

Added \CompensationEventProcessor\ and \CompensationFilter\ (including \DomainEventCompensationFilter\ and \StateEventCompensationFilter\) to the compensation core module. These components intercept domain and state events, capturing execution failures and success states to trigger compensation logic via the command bus, supporting both recoverable and non-recoverable error handling.

compensation/wow-compensation-core/src/main · medium confidence

Added a new proxy infrastructure in the \wow-core\ module to create dynamic JDK proxies for \PrepareKey\ interfaces. This includes the \PrepareKeyProxyFactory\ interface and its \DefaultPrepareKeyProxyFactory\ implementation, which uses Java's \Proxy\ class to delegate calls to underlying \PrepareKey\ instances. The change also introduces \PrepareKeyMetadata\ to hold configuration details and a \PrepareKeyMetadataParser\ to extract metadata from annotated interfaces, enabling more flexible and performant handling of prepare key operations.

wow-core/src/main/kotlin/me/ahoo/wow/infra/prepare/proxy · high confidence

Added new classes in the messaging compensation package to support event compensation. CompensationMatcher provides header-based matching logic and utility functions to mark messages for compensation, while EventCompensateSupporter routes compensation requests to the appropriate domain or state event compensators based on function kind. The EventCompensator interface defines the contract for resending events for compensation purposes.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/compensation · high confidence

The messaging subsystem now includes concrete implementations for in-memory and local-first message routing. A new \InMemoryMessageBus\ provides a thread-safe, in-JVM message distribution mechanism using Reactor Sinks, supporting subscriber counting and graceful shutdown. Additionally, a \LocalFirstMessageBus\ interface is introduced to prioritize local message handling before falling back to distributed routing, with support for local-first header flags and automatic merging of local and distributed message streams. The \MessageBus\ interface is also updated to explicitly define \send\ and \receive\ operations, replacing previous implicit behaviors.

wow-core/src/main/kotlin/me/ahoo/wow/messaging · high confidence

Added CommandFactory, CommandResultCapable, LocalFirstCommandBus, RequestIdChecker, and Validators, while refactoring CommandBus, CommandExceptions, CommandExchange, CommandGateway, CommandOperator, and CommandResult to support new command processing capabilities.

wow-core/src/main/kotlin/me/ahoo/wow/command · high confidence

The \wow-core\ module now includes new abstractions for the filter pipeline and error handling: \ErrorAccessor\ for tracking errors in a context, \Filter\ and \FilterChain\ to define and execute a chain of filters, and \Handler\/\ErrorHandler\ interfaces with \LogErrorHandler\ and \LogResumeErrorHandler\ implementations that use Kotlin-Logging. A \FilterChainBuilder\ is also provided to construct filter chains with conditional filtering and ordering. These changes shift the framework's internal processing model to use these new interfaces, which may affect how custom filters and error handlers are registered and invoked.

wow-core/src/main/kotlin/me/ahoo/wow/filter · medium confidence

The \wow-query\ module now includes a comprehensive set of new files that establish a modern, fluent API for constructing and executing queries. This includes the \QueryService\ interface for standard data queries, the \EventStreamQueryService\ for event stream queries, and a full suite of DSL classes (such as \ConditionDsl\, \ListQueryDsl\, and \ProjectionDsl\) that allow users to build complex query conditions, projections, and sorting criteria in a readable, chainable manner. Additionally, new converter classes like \AbstractConditionConverter\ and \AbstractProjectionConverter\ provide the underlying logic to translate these DSL structures into executable query formats.

wow-query · high confidence

Added a new state event bus system to support event sourcing by combining domain events with aggregate state. This includes the StateEvent interface and its implementation StateEventData, which wrap domain event streams with the current state. The system provides a LocalStateEventBus interface for in-memory, same-JVM messaging (implemented by InMemoryStateEventBus) and a LocalFirstStateEventBus that prioritizes local delivery before forwarding to a distributed bus. A SendStateEventFilter is also added to automatically publish state events after command processing, ensuring subscribers receive both the event and the updated state.

wow-core/src/main/kotlin/me/ahoo/wow/eventsourcing/state · high confidence

The file previously containing the DefaultDeleteAggregateTest has been renamed and repurposed as StateToCacheDataConverter, a functional interface in the me.ahoo.wow.cache package. This interface defines a stateToCacheData method for converting state objects into cache data, replacing the previous test file and associated test dependencies.

wow-cocache/src/main/kotlin/me/ahoo/wow/cache · high confidence

The API module now includes a new ABAC (Attribute-Based Access Control) tag system. This adds core type aliases and interfaces for managing entity tags, including \AbacTaggable\ for attaching tags to state aggregates and \AbacTagsExtractor\ for dynamic tag extraction. It also introduces \ApplyAbacTags\ and \ApplyResourceTags\ interfaces to handle the application of these tags, along with default implementations and associated domain events (\AbacTagsApplied\, \ResourceTagsApplied\) to signal when tags have been successfully applied.

wow-api/src/main/kotlin/me/ahoo/wow/api/abac · medium confidence

The Wow Spring Boot Starter now supports routing event and snapshot stores to different backends (MongoDB, Redis, Elasticsearch, In-Memory, or Delay) on a per-aggregate basis. This is achieved through new configuration properties (\StorageRoutingProperties\) and a \StorageRouteResolver\ that maps aggregate names to specific storage implementations. This allows users to configure, for example, using Elasticsearch for hot aggregates and MongoDB for cold ones, with the auto-configuration wiring the appropriate \EventStore\ and \SnapshotStore\ beans based on these routes.

wow-spring-boot-starter · high confidence

The MongoDB module now includes a schema initializer script (init-schema.js) that creates the 'event\_stream' and 'snapshot' collections with hashed indexes on 'aggregateId' and 'tenantId', and enables sharding for these collections in 'wow\_db' and 'compensation\_db'. A new 'RecoverableExceptionProvider' registers transient MongoDB errors (e.g., 'MongoSocketException', 'MongoTimeoutException') as recoverable, enabling automatic retry for network and replica set state changes. The module also introduces a full query service architecture: an 'AbstractMongoQueryService' with 'MongoProjectionConverter' and 'MongoSortConverter' for filtering, sorting, and projecting, which is used by 'MongoEventStreamQueryService' and 'MongoSnapshotQueryService' to support dynamic and typed queries. Additionally, 'ErrorMapping.kt' maps MongoDB write exceptions to domain-specific exceptions like 'EventVersionConflictException' and 'DuplicateRequestIdException'.

wow-mongo · high confidence

Two new client interfaces are introduced to query cart data: \CartQueryClient\ for reactive operations and \CartQuerySyncClient\ for synchronous operations. Both expose methods for retrieving single states, listing, and paginating cart aggregates via the \ExampleService.CartAggregateName\ endpoint, enabling consumers to fetch cart snapshots and state in either asynchronous or blocking styles.

example/example-api/src/main/kotlin/me/ahoo/wow/example/api/client · medium confidence

The API client now introduces new \CommandRequest\ and \RestCommandGateway\ interfaces that support passing \spaceId\, \ownerId\, \localFirst\, and other metadata as HTTP headers rather than path parameters. This enables namespace-based isolation and local-first execution modes for commands sent via the REST gateway, allowing clients to control routing and execution context through request headers.

wow-apiclient/src/main/kotlin/me/ahoo/wow/apiclient/command · high confidence

The aggregate testing DSL in \wow-test\ has been refactored to support branching test scenarios and custom test naming. A new \AggregateDslContext\ interface and \DefaultAggregateDslContext\ implementation allow tests to mark verification points using \ref()\ and create independent test branches from them via \fork()\. The \DefaultAggregateDsl\ now exposes a \fork\ method to execute alternative scenarios from a previously marked state. Additionally, the \GivenDsl\ and \WhenDsl\ interfaces now support specifying a custom \name\ for test scenarios, which is used in dynamic test reporting and naming.

test/wow-test/src/main/kotlin/me/ahoo/wow/test/aggregate/dsl · high confidence

Added new annotations to the API layer: \@AfterCommand\ for post-command processing, \@PreparableKey\ for optimistic concurrency and resource reservation, \@Retry\ for configurable retry policies, and \@VoidCommand\ for commands that don't require aggregate processing. Additionally, \@CommandRoute\ was enhanced with \HeaderVariable\ support, \appendOwnerPath\ configuration, and \Method\/\AppendPath\ enums, while \@AggregateRoute\ was introduced to configure routing and ownership behavior for aggregates.

wow-api/src/main/kotlin/me/ahoo/wow/api/annotation · high confidence

The wow-api module introduces several new interfaces in the naming package to standardize how entities expose metadata and state. These include CompletedCapable for tracking completion status, DescriptionCapable for human-readable descriptions, SummaryCapable for concise overviews, and EnabledCapable for active/inactive states. Additionally, QualifiedNamed and Named provide standardized access to fully qualified and simple names, while Materialized marks entities with computed data. The existing NamedBoundedContext interface was also updated to include an isSameBoundedContext method for context comparison.

wow-api/src/main/kotlin/me/ahoo/wow/api/naming · high confidence

The framework introduces a new \CommandBuilder\ interface and \CommandMessageFactory\ to construct command messages, supporting properties like \spaceId\, \ownerId\, and \requestId\. A \CommandBuilderRewriter\ system allows modifying commands before execution, with automatic handling of blocking operations via a \@Blocking\ annotation. The \SimpleCommandMessageFactory\ integrates validation and rewriter application, ensuring commands are properly transformed and validated before processing.

wow-core/src/main/kotlin/me/ahoo/wow/command/factory · medium confidence

The compensation server now includes dedicated Spring configuration classes to manage server behavior and documentation. A new CompensationConfiguration registers a default NextRetryAtCalculator and a CORS filter, while CompensationProperties exposes retry-related settings (max retries, backoff, and timeout) via Spring Boot configuration properties. Additionally, SwaggerConfiguration sets up OpenAPI documentation for the Wow Compensation Service, including title, description, and versioning based on the current Wow.VERSION.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/configuration · high confidence

The dashboard's utility layer now includes a new \dates.ts\ module that provides a \formatDate\ function for converting timestamps into readable strings using the dayjs library, alongside a \useQueryParams\ hook that simplifies accessing URL query parameters in React components. Both utilities come with comprehensive test coverage, ensuring that date formatting handles various templates and edge cases, while the query parameter hook correctly parses and returns specific or all query string values from the current URL.

compensation/dashboard/src/utils · high confidence

Added DomainEventCompensator and StateEventCompensator classes in the event compensation package. DomainEventCompensator handles compensation for domain events by resending event streams to the domain event bus with compensation metadata. StateEventCompensator handles compensation for state events by reconstructing state from event sourcing and resending state events to the state event bus with compensation metadata. Both classes implement the EventCompensator interface and provide methods to compensate individual events or resend ranges of events from the event store.

wow-core/src/main/kotlin/me/ahoo/wow/event/compensation · high confidence

Added new domain event interfaces to support aggregate recovery, ownership transfer, and namespace (space) transfer. Specifically, the diff introduces \AggregateRecovered\ and \DefaultAggregateRecovered\ to handle the restoration of deleted aggregates, \OwnerTransferred\ (with a \toOwnerId\ property) to track ownership changes, and \SpaceTransferred\ (with a \toSpaceId\ property) to manage namespace-based data isolation. Additionally, the \EventMessage\ interface was refactored to include \OwnerId\ and \SpaceIdCapable\ capabilities, while \DomainEvent\ was updated to extend \EventMessage\ and \Revision\, and \AggregateDeleted\ was updated with documentation and a default implementation.

wow-api/src/main/kotlin/me/ahoo/wow/api/event · high confidence

The library introduces new interfaces to manage component lifecycles and graceful shutdowns. A new \GracefullyStoppable\ interface is added, providing synchronous and asynchronous methods to stop a resource gracefully, with a default 30-second timeout. The \Lifecycle\ interface is introduced to manage component start and stop operations, extending \GracefullyStoppable\. Additionally, the \TerminatedSignalCapable\ interface is added (renamed and moved from \Filter.kt\), allowing components to expose a \Mono\ signal for termination. These changes enable developers to implement cleaner shutdown logic and lifecycle management for services and dispatchers.

wow-core/src/main/kotlin/me/ahoo/wow/infra/lifecycle · high confidence

A new message propagation system has been introduced to carry context across message boundaries. This includes a \MessagePropagator\ interface and a \MessagePropagatorProvider\ that loads all implementations via ServiceLoader. Specific propagators are now available: \TraceMessagePropagator\ for distributed tracing (propagating trace IDs and upstream message details), \CommandOperatorMessagePropagator\ to maintain operator context, \CommandRequestHeaderPropagator\ to forward user agent and remote IP headers (controlled by the \wow.messaging.propagation.request\ system property), and \WaitPlanMessagePropagator\ to propagate wait plan headers.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/propagation · high confidence

The modeling API introduces a suite of new interfaces to standardize how entities and aggregates expose metadata about their lifecycle and identity. These include \CreateTimeCapable\ and \EventTimeCapable\ for timestamp tracking, \OperatorCapable\ and \FirstOperatorCapable\ for audit trails, \DeletedCapable\ for soft deletion status, and \SpaceIdCapable\ for namespace-based data isolation. Additionally, \MaterializeState\ and \StateCapable\ provide contracts for state representation and materialization, while \OwnerId\ and \TenantId\ interfaces formalize resource ownership and multi-tenancy support.

wow-api/src/main/kotlin/me/ahoo/wow/api/modeling · high confidence

The \wow-api\ module introduces a comprehensive query API, adding new interfaces and data classes for building and executing queries. The \Condition\ class and \ICondition\ interface provide a structured way to define filtering criteria, supporting logical operators (AND, OR, NOR) and nested conditions. \ListQuery\, \PagedQuery\, and \SingleQuery\ implement \Queryable\, which combines \ConditionCapable\, \ProjectionCapable\, and \SortCapable\ to allow fluent modification of conditions, field projections, and sort orders. Additional support includes \DynamicDocument\ for handling arbitrary key-value data, \DeletionState\ for filtering by entity status, and \Operator\ for defining comparison and logical operations. \MaterializedSnapshot\ and \MediumMaterializedSnapshot\ provide interfaces and implementations for managing aggregate state snapshots with metadata like tenant, owner, and event tracking.

wow-api/src/main/kotlin/me/ahoo/wow/api/query · high confidence

Added new reactive extension functions \thenDefer\ and \thenRunnable\ to the \Mono\ class, enabling deferred execution and side-effect handling in reactive chains. Additionally, introduced a configurable \ReactorCheckpoint\ system that allows users to control the verbosity of Reactor debugging checkpoints via the \wow.reactor.checkpoint-level\ property or \WOW\_REACTOR\_CHECKPOINT\_LEVEL\ environment variable, supporting OFF, LIGHT, and HEAVY levels.

wow-core/src/main/kotlin/me/ahoo/wow/reactor · high confidence

The schema generation system has been refactored to use a new \SchemaGeneratorBuilder\ that configures various modules (Jackson, Jakarta Validation, Swagger2, Kotlin, Joda Money, and Wow-specific modules) to produce JSON and OpenAPI schemas. This change introduces new classes such as \JsonSchema\, \DescriptionResolver\, \SummaryTitleResolver\, and \TypeFieldPaths\ to handle schema creation, field path resolution, and annotation processing, providing a more flexible and modular approach to schema generation.

wow-schema · high confidence

The framework introduces a centralized \ErrorCodes\ object defining standardized error codes (e.g., \NOT\_FOUND\, \ILlegal\_ARGUMENT\) and a new \ErrorInfoConverter\ system that maps exceptions to \ErrorInfo\ objects. This includes a \DefaultErrorInfoConverter\ and a \RecoverableExceptionRegistrar\ that allows custom classification of exceptions as recoverable or unrecoverable. Additionally, the \NotFoundResourceException\ and its associated reactive extension functions (\throwNotFoundIfEmpty\, \throwNotFoundIfNull\) have been refactored to use these new centralized codes and exception handling patterns.

wow-core/src/main/kotlin/me/ahoo/wow/exception · high confidence

The framework now allows registering multiple after-command functions, each with configurable include/exclude rules and execution order. This enables users to define custom post-command processing logic that runs after command execution, with the ability to control the order in which these functions are invoked via an Ordered interface. The new AfterCommandFunction and AfterCommandFunctionMetadata classes provide the foundation for this multi-function support.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/command/after · medium confidence

The R2DBC-based persistence layer has been removed from the \wow-r2dbc\ module. This includes the deletion of all related source files, such as \R2dbcEventStore\, \R2dbcSnapshotRepository\, and their associated schema and test files. This change eliminates the ability to store event streams and snapshots in a relational database via R2DBC, requiring users to adopt an alternative storage backend.

wow-r2dbc · high confidence

The \MethodAccessor\ interface and the \MonoMethodAccessorFactory\ (including \MonoMethodAccessor\ and related classes) have been removed from the \wow-core\ module. This change eliminates deprecated or legacy reflection-based method invocation mechanisms, likely to be replaced by newer accessor implementations or functional interfaces as suggested by the commit messages referencing \FunctionAccessor\ and \AnnotationPropertyAccessorParser\.

wow-core/src/main/kotlin/me/ahoo/wow/infra/accessor/method · high confidence

The messaging handler package has been restructured to improve modularity and reliability. A new \ExchangeAck\ utility provides \finallyAck\ and \filterThenAck\ extension functions to ensure message exchanges are acknowledged regardless of processing success or failure. The previous \FilterChainBuilder\ and \Handler\ interfaces have been removed and replaced with a cleaner \ExchangeFilter\ interface and a \RetryFilter\ that applies exponential backoff for recoverable errors. Additionally, the \MessageExchange\ interface has been enhanced with a generic attribute system, support for \FunctionInfo\, \CommandResultAccessor\, and aggregate version tracking, while \extractObject\ now uses \KType\ for better type safety.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/handler · high confidence

The \wow-openapi\ module has been refactored to improve the structure and maintainability of OpenAPI schema generation. This change introduces several new classes to handle specific aspects of the API documentation: \ApiResponseBuilder\ and \RequestBodyBuilder\ for constructing response and request body definitions; \CommonComponent\ for shared headers, parameters, and error responses; \QueryComponent\ for query-related schemas and request bodies; \CommandComponent\ for command headers and parameters; and \EventComponent\ for event compensation. Additionally, a \RouteCatalog\ and \RouteCatalogBuilder\ are introduced to manage and validate route contracts, while \RouterSpecs\ orchestrates the merging of these components into the final OpenAPI specification. These changes streamline how API routes, schemas, and metadata are generated and organized within the OpenAPI specification.

wow-openapi · high confidence

The CommandMetadata class now includes an ownerIdGetter property to track the owner of a command, and a staticTenantId property that extracts a static tenant ID when the tenant ID getter is a static property. Additionally, the class now supports void commands via the isVoid flag, and the code has been refactored to use single-expression functions for hashCode and toString.

wow-core/src/main/kotlin/me/ahoo/wow/command/metadata · high confidence

The server now automatically configures sharding for key collections, including order\_snapshot, order\_event\_stream, cart\_snapshot, and cart\_event\_stream, using hashed keys to ensure even data distribution across the cluster.

example/example-server/src/init-schema · medium confidence

The cart API commands have been refactored to use the new \@CommandRoute\ annotation for defining HTTP routes and ordering, replacing the previous \@CommandRoute\ string-based path definitions. \AddCartItem\, \ChangeQuantity\, and \RemoveCartItem\ now include \@Order\ annotations to define execution order. Validation constraints (\@NotBlank\, \@Positive\, \@NotEmpty\) are added to command fields. \InitializeCart\ is removed, and new commands like \MockVariableCommand\ and \MountedCommand\ are added to demonstrate variable path parameters and mount commands. \ViewCart\ is added as a \@VoidCommand\.

example/example-api/src/main/kotlin/me/ahoo/wow/example/api/cart · high confidence

The Cart aggregate now supports routing by aggregate ID, enabling more precise request targeting. New command types (MountedCommand, ViewCart, MockVariableCommand) are supported, and the AddCartItem handler now returns an Any type to accommodate various outcomes. The CartSaga has been updated to use the new CommandBuilder API for constructing commands, and the CartState now implements the ICartInfo interface for better state management.

example/example-domain/src/main/kotlin/me/ahoo/wow/example/domain/cart · high confidence

The \wow-webflux\ module introduces a centralized exception handling and response strategy for HTTP routes. A new \DefaultGlobalExceptionHandler\ and \WebFluxErrorStrategy\ provide a unified way to convert exceptions into standardized \ErrorInfo\ responses with appropriate HTTP status codes. Specific converters handle Spring's \HandlerMethodValidationException\, \NoResourceFoundException\, and \ResponseStatusException\. Additionally, a \RequestExceptionHandler\ interface and \BatchResults\ utility are added to manage route-level errors and batch operation outcomes, ensuring consistent error reporting across the WebFlux layer.

wow-webflux · high confidence

The command serialization logic has been refactored to support \VoidCommand\ by introducing an \isVoid\ flag in the JSON payload. Additionally, the serializer now writes and reads \ownerId\ and \spaceId\ fields, enabling namespace-based data isolation and owner tracking for commands. The implementation also migrates from the \com.fasterxml.jackson\ library to \tools.jackson\ and updates helper methods (e.g., \asType\ to \toType\).

wow-core/src/main/kotlin/me/ahoo/wow/serialization/command · high confidence

The configuration layer has been refactored to use Kotlin-logging instead of SLF4J, updating all logger instantiations in the configuration package. The \WowMetadata\ model now includes a \description\ field and validates for duplicate bounded context aliases during initialization. Additionally, the \Aggregate\ model supports a static \tenantId\ and uses \linkedSetOf\ for scopes, commands, and events to preserve insertion order. Searcher extension functions (e.g., \toTypeNamedAggregateSearcher\) have been renamed and restructured to return typed searcher instances directly, and error messages in the \ScopeSearcher\ have been improved for clarity.

wow-core/src/main/kotlin/me/ahoo/wow/configuration · high confidence

The Spring bean for the CreateOrderSpec is now explicitly named "createOrderSpec" instead of using the default method-name-based naming. This ensures the bean can be referenced by a specific identifier within the application context.

example/example-server/src/main/kotlin/me/ahoo/wow/example/server/configuration · high confidence

The dashboard now uses a centralized controller to serve the main index.html file for all navigation routes, including /to-retry, /executing, /next-retry, /non-retryable, /succeeded, and /unrecoverable. This change replaces the previous file-loading mechanism with a resource-loader approach, ensuring consistent handling of the dashboard's static content across all navigation paths.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/dashboard · medium confidence

The ServiceProvider interface now supports name-based service resolution alongside type-based lookups, allowing services to be registered and retrieved by a custom string name. The SimpleServiceProvider implementation has been updated to use Kotlin's KType for type registration and retrieval, enabling more precise generic type matching. Additionally, the service resolution logic now performs subtype matching to find compatible registered services, and includes a fallback to Java class instance checks to address compatibility issues with libraries like MockK. The interface also introduces a serviceNames property to discover available services and implements Copyable to support deep copying and merging of service providers.

wow-core/src/main/kotlin/me/ahoo/wow/ioc · high confidence

The KSP SymbolProcessorProvider configuration file has been updated to register new processors for generating StateAggregate query navigation properties, metadata, and aggregate metadata. This change enables the framework to automatically generate code for these specific aspects of the CQRS architecture, supporting the modern reactive CQRS microservice development approach.

wow-compiler/src/main/resources · high confidence

The EventMetadata class now includes comprehensive KDoc documentation explaining its role as a metadata container for domain events, detailing its properties such as eventType, namedAggregateGetter, name, revision, and aggregateIdGetter. Additionally, the code style has been refactored to use Kotlin's expression body syntax for hashCode() and toString(), and the import path for NamedAggregateGetter has been corrected from 'me.ahoo.wow.modeling.matedata' to 'me.ahoo.wow.modeling.metadata'.

wow-core/src/main/kotlin/me/ahoo/wow/event/metadata · medium confidence

Developers can now access the current bounded context via a new \CurrentContextCapable\ interface and a \CurrentBoundedContext\ object, enabling runtime context awareness in naming strategies. Additionally, the \NamingConverter\ interface is now a functional interface with added convenience methods like \pascalToSnake()\, and the \MaterializedNamedBoundedContext\ class gains a \getContextAlias\ function to support context aliasing.

wow-core/src/main/kotlin/me/ahoo/wow/naming · high confidence

The core library adds a new \FunctionInvokerFactory\ and a suite of invoker implementations in the \me.ahoo.wow.infra.invoker\ package. The system now attempts to invoke functions and constructors using \java.lang.invoke.MethodHandle\ for improved performance, while falling back to standard reflection if \MethodHandle\ is unavailable. This change introduces interfaces (\FunctionInvoker\, \InstanceFunctionInvoker\, \ReceiverlessFunctionInvoker\) and concrete implementations (\MethodHandleInstanceFunctionInvoker\, \ReflectionInstanceFunctionInvoker\, etc.) that handle method and constructor invocation with optimized fast paths for up to nine arguments.

wow-core/src/main/java · high confidence

Added a new \ReadOnlyStateAggregate\ interface that provides read-only access to aggregate state, version, timing, and ownership metadata. The \StateAggregate\ interface now extends it, and \SimpleStateAggregate\ was updated to track additional properties including \ownerId\, \spaceId\, \eventId\, \firstOperator\, \operator\, \firstEventTime\, \eventTime\, and \tags\. The \StateAggregateRepository\ now supports loading aggregates by version or event time, and the \StateAggregateFactory\ was refactored to support constructing state aggregates with these new properties.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/state · high confidence

The \CacheableMetadataParser\ abstract class has been refactored to provide a thread-safe caching mechanism for metadata parsing. It now uses a \ConcurrentHashMap\ to store parsed metadata, ensuring safe concurrent access and updates. The \Metadata\ interface is also updated to serve as a marker interface for metadata objects in the Wow framework. This change improves performance by avoiding repeated parsing of the same class metadata.

wow-core/src/main/kotlin/me/ahoo/wow/metadata · medium confidence

The JSON serialization engine has been upgraded from Jackson 2 to Jackson 4, which enables final fields as mutators and improves performance. The \JsonSerializer\ singleton now uses the new \tools.jackson\ API, and extension functions like \toJsonString\ and \toPrettyJson\ have been updated to use the new library. Additionally, the serialization layer now supports \ownerId\ and \spaceId\ fields in message records, and the \WowModule\ registers serializers for \StateEvent\ and \AggregateId\. The \AbstractStateAggregateSerializer\ and \EventStreamJsonSerializer\ have been removed or refactored to align with these changes.

wow-core/src/main/kotlin/me/ahoo/wow/serialization · high confidence

The compensation dashboard has been migrated from Angular to React, introducing a new routing configuration in src/routes. The app now uses React Router's createBrowserRouter to define navigation for failed compensation states (To Retry, Executing, Next Retry, Non-Retryable, Succeeded, Unrecoverable). Each route renders a lazy-loaded FailedView component wrapped in a React Suspense boundary that displays an Ant Design Skeleton during loading. Route constants and navigation items are extracted into a dedicated constants file, and unit tests have been added to verify the router and constants.

compensation/dashboard/src/routes · high confidence

The event serialization layer in wow-core has been refactored to use Jackson (tools.jackson) instead of the previous implementation, introducing new serializer classes like AbstractEventStreamJsonSerializer and StateEventJsonSerializer. As part of this migration, domain events and event streams now explicitly serialize and deserialize owner and space identifiers (ownerId, spaceId) alongside existing metadata like tenantId and version. The DomainEventRecord and EventStreamRecord interfaces have been updated to include these new fields, and the deserialization logic has been adjusted to resolve event types via the new EventTypeRegistry. Additionally, the BodyTypeNotFoundDomainEvent has been renamed to JsonDomainEvent and updated to include owner and space context.

wow-core/src/main/kotlin/me/ahoo/wow/serialization/event · high confidence

The example server application has been updated to integrate with the new Co-Api client infrastructure. The \ExampleServer\ class now enables \ReactiveRestCommandGateway\, \CartQueryClient\, and \CartQuerySyncClient\ via the \@EnableCoApi\ annotation, replacing the previous configuration. Additionally, the server's bounded context has been simplified to \ExampleBoundedContext\, and the manual Micrometer logging registry setup has been removed.

example/example-server/src/main/kotlin/me/ahoo/wow/example/server · medium confidence

The ID generation subsystem in wow-core has been refactored to use Kotlin-logging instead of SLF4J, updating all affected classes (AggregateIdGenerator, CosIdAggregateIdGeneratorFactory, CosIdGlobalIdGeneratorFactory, GlobalIdGenerator) to use KotlinLogging. The code also introduces a new \generateGlobalId()\ function and a \NotInitializedGlobalIdGeneratorError\ exception, while replacing the custom \OrderComparator\ with a \sortedByOrder()\ extension for sorting service-loaded factories.

wow-core/src/main/kotlin/me/ahoo/wow/id · high confidence

The GlobalDrawer component and its associated context (GlobalDrawerProvider, useGlobalDrawer) have been rewritten in React, replacing the previous implementation. This change introduces a new ErrorBoundary component to handle rendering errors gracefully within the dashboard. The migration includes updated tests for the GlobalDrawer and ErrorBoundary components, ensuring the new React-based UI behaves as expected.

compensation/dashboard/src/components · high confidence

The compensation dashboard's main application component has been rewritten in React, replacing the previous Angular implementation. This change introduces a new header with a logo, a horizontal navigation menu for internal routes, and external links to GitHub and Gitee repositories. The layout now utilizes Ant Design's Layout, Menu, and Watermark components, and integrates React Router for navigation and error boundary handling.

compensation/dashboard/src/features/App · high confidence

Added a new Strings.kt file providing the ifNotBlank extension function for safe string operations, renamed the type mapping method from asType to toType in TypeNameMapper, and updated the Decorator interface with a getOriginalDelegate method to recursively unwrap decorated components.

wow-core/src/main/kotlin/me/ahoo/wow/infra · high confidence

The framework now caches the hash code for aggregate IDs and materialized named aggregates, ensuring that repeated calls to hashCode() return the same value without recomputation. Additionally, the string representation of named aggregates now supports context aliases, allowing for more concise and readable output when displaying aggregate identities.

wow-core/src/main/kotlin/me/ahoo/wow/modeling · medium confidence

The Order aggregate now supports setting command results via CommandResultAccessor, allowing the creation of orders to return calculated fields like totalAmount. The OrderState model now implements StatusCapable and StateAggregateTagsExtractor, enabling automatic extraction of ABAC tags (e.g., address country and province) for access control. Additionally, the OrderSaga was moved to the domain layer and updated to handle state events, while the CreateOrderSpec interface was adjusted to use the new CreateOrderItem type.

example/example-domain/src/main/kotlin/me/ahoo/wow/example/domain/order · high confidence

The /order/{tenantId}/{orderId} query endpoint in the example server has been updated to use the new SnapshotQueryService API instead of the previous StateAggregateRepository approach. This change replaces the manual aggregate ID construction and repository loading with a declarative query builder (singleQuery) that directly retrieves the state from the snapshot store, simplifying the controller logic and aligning with the framework's new query abstractions.

example/example-server/src/main/kotlin/me/ahoo/wow/example/server/order · high confidence

The projection subsystem has been refactored to use the new dispatcher and filter interfaces. The \ProjectionDispatcher\ now extends \CompositeEventDispatcher\ and accepts a \StateEventBus\ in addition to the \DomainEventBus\, while the scheduler supplier is now a typed \AggregateSchedulerSupplier\ rather than a raw function. The \ProjectionFunctionFilter\ and \ProjectionFunctionRegistrar\ have been updated to extend the new \DomainEventFunctionFilter\ and \AbstractEventFunctionRegistrar\ respectively, and the \DefaultProjectionHandler\ now extends \AbstractHandler\ from the filter package. These changes align projection processing with the framework's updated event and message handling architecture.

wow-core/src/main/kotlin/me/ahoo/wow/projection · high confidence

The \ProjectionProcessorMetadataParser\ has been updated to recognize the new \OnStateEvent\ annotation in addition to \OnEvent\. This allows projection processors to be triggered by state events, expanding the types of events that can drive projection logic.

wow-core/src/main/kotlin/me/ahoo/wow/projection/annotation · high confidence

The reactive function accessor system has been refactored to support a wider range of return types and execution models. A new \AbstractMonoFunctionAccessor\ base class and \MonoMethodAccessorFactory\ now automatically select the appropriate accessor implementation based on the function's return type, supporting \Mono\, \Flux\, \Publisher\, and synchronous functions. New accessor classes have been introduced: \BlockingMonoFunctionAccessor\ for handling blocking operations on separate threads, \FlowMonoFunctionAccessor\ for Kotlin \Flow\ streams, \FluxMonoFunctionAccessor\ for \Flux\ streams, \PublisherMonoFunctionAccessor\ for \Publisher\ streams, and \SyncMonoFunctionAccessor\ for synchronous functions. The previous \FieldSetter\ interface has been removed and replaced with \SuspendMonoFunctionAccessor\ for suspend functions, which now properly unwraps \InvocationTargetException\ to propagate the original cause.

wow-core/src/main/kotlin/me/ahoo/wow/infra/accessor/function/reactive · high confidence

The command wait mechanism has been completely refactored to support complex, chained wait conditions. The previous \WaitStrategy\ and \WaitStrategyRegistrar\ have been replaced by a new \WaitPlan\-based system. Users can now wait for specific command stages (SENT, PROCESSED, SNAPSHOT, Jeta, EVENT\_HANDLED, SAGA\_HANDLED) with optional function matching. Additionally, the system now supports \ChainWaitTarget\ and \SimpleWaitingChain\ to define sequences of stages to wait for, allowing for more granular control over asynchronous command processing results. The \CommandWait\ object provides factory methods to create these wait plans, and the \WaitCoordinator\ manages the lifecycle of wait handles.

wow-core/src/main/kotlin/me/ahoo/wow/command/wait · high confidence

The idempotency checking mechanism has been refactored to use a synchronous boolean return type instead of a reactive Mono, simplifying the API for consumers. A new AggregateIdempotencyCheckerProvider interface and its DefaultAggregateIdempotencyCheckerProvider implementation have been added to support aggregate-specific idempotency checkers. Additionally, a NoOpIdempotencyChecker singleton was introduced to allow disabling idempotency checks when needed.

wow-core/src/main/kotlin/me/ahoo/wow/infra/idempotency · high confidence

The Kafka message buses (Command, Domain Event, and State Event) have been refactored to use pluggable topic converters (e.g., DefaultCommandTopicConverter) instead of hardcoded topic naming, allowing for more flexible topic naming strategies. Additionally, message subscription is now explicit via the \MessageSubscription\ interface, and the internal \AbstractKafkaBus\ has been updated to use \SenderOptions\ and \ReceiverOptions\ directly rather than a shared \KafkaSender\ instance, improving resource management and testability. The \acknowledge()\ method on exchange objects now returns a \Mono\<Void\>\ for better reactive stream integration.

wow-kafka · high confidence

The PrepareKey interface has been refactored to support temporary reservations with time-to-live (TTL) expiration, enabling automatic cleanup of prepared keys. The API now uses extension functions to convert values into PreparedValue objects (replacing the previous asForever/asTtlAt methods), and the reprepare method now accepts a new value directly rather than requiring the old value for comparison. These changes allow developers to create temporary key reservations that expire automatically, improving resource management in event-sourced applications.

wow-core/src/main/kotlin/me/ahoo/wow/infra/prepare · medium confidence

The command metadata parser has been refactored to use Kotlin reflection (KProperty1) instead of Java reflection (Field/Method), and now leverages the new AnnotationPropertyAccessorParser for extracting property getters. This change introduces support for ownerId in commands and static tenantId, while removing unused logging and improving code clarity.

wow-core/src/main/kotlin/me/ahoo/wow/command/annotation · medium confidence

The compiler's code generation logic has been refactored to improve structure and support for tenant IDs. A new \GeneratedFile\ data class has been introduced to encapsulate the process of writing generated Kotlin files, separating the representation of a generated file from the code generation logic. Additionally, the \AggregateRootResolver\ has been updated to support static \tenantId\ in constructors, allowing aggregate roots to be initialized with both an ID and a tenant ID. The resolver now returns an \AggregateRootMetadata\ object, which bundles the command and state class declarations, simplifying how metadata is handled downstream.

wow-compiler/src/main/kotlin/me/ahoo/wow/compiler · medium confidence

The event metadata and processor parsers have been refactored to use modern Kotlin reflection APIs (e.g., \KProperty1\, \Class.kotlin.visit\) and updated extension functions (e.g., \toEventMetadata\, \eventProcessorMetadata\). This change improves type safety and aligns with the framework's move toward Kotlin-native reflection and property accessors, ensuring more robust event metadata extraction and processor configuration.

wow-core/src/main/kotlin/me/ahoo/wow/event/annotation · high confidence

The event upgrader module was refactored to improve code clarity and logging. Extension functions for transforming domain event records were renamed (e.g., \asMutableDomainEventRecord\ to \toMutableDomainEventRecord\, \asDroppedEventRecord\ to \toDroppedEventRecord\) to better reflect their conversion nature. The \EventUpgraderFactory\ was updated to use \kotlin-logging\ instead of \slf4j\, and the internal storage for upgraders was changed from \SortedSet\ to \List\ with explicit sorting via \sortedByOrder()\. Additionally, \MutableDomainEventRecord\ was expanded to store additional metadata (header, aggregate ID, etc.) directly rather than relying on the underlying \ObjectNode\ for all properties.

wow-core/src/main/kotlin/me/ahoo/wow/event/upgrader · high confidence

The metrics subsystem in wow-core has been refactored to use a new \AbstractMetricDecorator\ base class that handles common tagging of reactive streams with source information. All existing metric decorators (for command buses, domain event buses, state event buses, handlers, and repositories) have been updated to extend this base class. Additionally, the codebase now explicitly distinguishes between local and distributed implementations for command and domain event buses (e.g., \MetricLocalCommandBus\, \MetricDistributedCommandBus\), and the \Metrics\ utility object now provides specific \metrizable()\ extension functions for each of these types. The \MetricSnapshotRepository\ has been deprecated in favor of \MetricSnapshotStore\.

wow-core/src/main/kotlin/me/ahoo/wow/metrics · high confidence

The property accessor implementation has been refactored to use Kotlin reflection (KProperty1, KMutableProperty1) instead of Java reflection (Method, Field) for accessing object properties. This change introduces a new StaticPropertyGetter to support static/constant values as property getters, and updates the PropertyDescriptor utility to provide factory methods (toPropertyGetter, toPropertySetter) for creating accessors from Kotlin properties. The underlying Accessor.kt file now includes an ensureAccessible() extension function for both Java's AccessibleObject and Kotlin's KCallable to handle accessibility flags.

wow-core/src/main/kotlin/me/ahoo/wow/infra/accessor/property · medium confidence

The reflection subsystem in wow-core has been refactored to use Kotlin reflection (KAnnotatedElement, KClass, etc.) instead of Java's java.lang.reflect. A new MergedAnnotation class and IntimateAnnotationElement provide logic to collect annotations from the entire inheritance hierarchy (superclasses, interfaces, and overridden members), ensuring that inherited annotations are discovered correctly. The existing AnnotationScanner has been updated to use this new mechanism, and the ClassMetadata/ClassVisitor interface has been modernized to work with Kotlin reflection types (KType, KFunction, KProperty) rather than Java's Class, Method, and Field. This change improves annotation scanning accuracy for frameworks relying on inherited metadata.

wow-core/src/main/kotlin/me/ahoo/wow/infra/reflection · high confidence

The \AbstractStateAggregateSerializer\ and related classes in \wow-core/src/main/kotlin/me/ahoo/wow/serialization/state\ have been refactored to include \ownerId\ and \spaceId\ in the serialized state of aggregates. This change updates the serialization and deserialization logic to handle these new fields, enabling namespace-based data isolation and owner identification in the state representation.

wow-core/src/main/kotlin/me/ahoo/wow/serialization/state · high confidence

The cache refresh logic in the \wow-cocache\ module has been refactored to improve performance and code structure. The \StateCacheRefresher\ has been split into separate classes: \EvictStateCacheRefresher\ for handling cache eviction and \SetStateCacheRefresher\ for setting cache values. The implementation now uses \Mono.fromRunnable\ for better asynchronous handling and includes an \evict\ method in \SetStateCacheRefresher\ to optimize cache invalidation. Additionally, the code has been updated to use KotlinLogging for logging.

wow-cocache/src/main/kotlin/me/ahoo/wow/cache/refresh · medium confidence

The cache source layer was restructured to improve modularity and configuration handling. A new \StateCacheSource\ interface was introduced to define the contract for loading state, which is now implemented by \QueryApiCacheSource\ and \QueryServiceCacheSource\. Additionally, \LoadCacheSourceConfiguration\ was added to manage cache timeout and TTL settings, replacing the previous \CacheValueConfiguration\ approach.

wow-cocache/src/main/kotlin/me/ahoo/wow/cache/source · high confidence

The command processing architecture in wow-core has been refactored to introduce a new class hierarchy for command functions. A new \AbstractCommandFunction\ base class and \CommandFunction\ wrapper were added to handle command execution and after-command functions. The \CommandAggregateMetadata\ and \StateAggregateMetadata\ models were moved to the \metadata\ package and updated to use \FunctionAccessorMetadata\ instead of \MethodFunctionMetadata\. Additionally, \AggregateCommandDispatcher\ was removed, \AggregateProcessorFilter\ was renamed to \ExchangeCommandAggregate\, and new exception classes (\IllegalAccessOwnerAggregateException\, \IllegalAccessSpaceAggregateException\) were introduced to handle specific access control scenarios.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/command · high confidence

The \ConstructorAccessor\ interface and its \DefaultConstructorAccessor\ implementation have been refactored to delegate constructor invocation to a \FunctionInvokerFactory\, which provides optimized fast paths for reflection-based instantiation. Additionally, \InjectableObjectFactory\ has been updated to use the new \ConstructorAccessor\ abstraction and leverages Kotlin reflection (\kotlinFunction\, \valueParameters\) to resolve constructor parameters from the \ServiceProvider\.

wow-core/src/main/kotlin/me/ahoo/wow/infra/accessor/constructor · medium confidence

The event handling architecture has been refactored to simplify the event processing pipeline. A new \DomainEventFactory\ and \DomainEventStreamFactory\ provide extension functions (\toDomainEvent\, \toDomainEventStream\) to convert objects and command messages into domain events and streams, replacing the previous \asDomainEvent\ and \asDomainEventStream\ methods. The \DomainEvent\ and \DomainEventStream\ interfaces have been updated to include \ownerId\ and \spaceId\ properties, supporting namespace-based data isolation. The \DomainEventBus\ interface has been split into \LocalDomainEventBus\ and \DistributedDomainEventBus\ to explicitly define local and distributed capabilities. Additionally, the \EventExchange\ interface has been introduced to replace \DomainEventHandler\, and the \AggregateEventDispatcher\ has been removed in favor of a more generic event processing model.

wow-core/src/main/kotlin/me/ahoo/wow/event · high confidence

The exception handling API was refactored to provide a more robust and standardized approach to error reporting. A new \ErrorInfoCapable\ interface was introduced to allow entities to supply error information in a consistent manner. The \ErrorInfo\ interface was expanded to include \bindingErrors\ for detailed validation feedback, with Jackson serialization annotations added to handle empty lists. Additionally, a \RecoverableType\ enum was added to classify errors as recoverable, unrecoverable, or unknown, enabling better retry and failure recovery strategies. The legacy \WowExceptions\ file, containing older exception classes and extension functions, was removed in favor of this new structure.

wow-api/src/main/kotlin/me/ahoo/wow/api/exception · high confidence

The messaging dispatcher package was restructured: the old \AbstractDispatcher\ and \AggregateMessageDispatcher\ classes were removed and replaced with new \AggregateDispatcher\ and \MainDispatcher\ abstract base classes, along with a \MessageDispatcher\ interface. The \SafeSubscriber\ class was updated to use \kotlin-logging\ instead of \slf4j\, and the \MessageParallelism\ utility was refactored to use a simpler \parallelism\ integer property instead of a \MessageParallelism\ data class, introducing a \ParallelismCapable\ interface. These changes alter how message dispatching is implemented and configured, particularly regarding parallelism settings and logging infrastructure.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/dispatcher · high confidence

The message function handling in wow-core has been refactored to use a new FunctionAccessorMetadata and SimpleMessageFunctionAccessor architecture. This introduces a cleaner separation between metadata (FunctionAccessorMetadata) and invocation logic (SimpleMessageFunctionAccessor/InjectableMessageFunctionAccessor), replacing the previous MethodFunctionMetadata and MethodMessageFunction approach. The new design supports dependency injection for function parameters, improves performance through fast paths, and provides better debugging capabilities with qualified names. The SimpleMessageFunctionRegistrar now supports filtering capabilities and topic-based indexing for more efficient message function lookup.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/function · medium confidence

The message processor metadata parsing logic has been refactored to use Kotlin reflection (KFunction) instead of Java reflection (Method), enabling more idiomatic Kotlin code. The parser now uses a functional condition (MessageAnnotationFunctionCondition) to filter functions, replacing the previous annotation-based filtering. Additionally, the internal visitor pattern has been updated to collect FunctionAccessorMetadata instead of MethodFunctionMetadata, and the ProcessorMetadata class now uses a functional approach to convert function metadata to message functions.

wow-core/src/main/kotlin/me/ahoo/wow/messaging/processor · medium confidence

The \wow-apiclient\ module now provides distinct interfaces for synchronous and reactive snapshot queries, including \SynchronousSnapshotQueryApi\ and \ReactiveSnapshotQueryApi\ along with their respective single, list, paged, and count variants. This separation allows users to choose the appropriate client style for their application, with each interface exposing specific HTTP endpoints (e.g., \/snapshot/single\, \/snapshot/list\) and helper functions for querying snapshots and their states.

wow-apiclient/src/main/kotlin/me/ahoo/wow/apiclient/query · high confidence

The snapshotting mechanism has been refactored to use a new \SnapshotStore\ interface, which replaces the previous \SnapshotRepository\ interface. This change simplifies the API by removing the \findAggregateId\ method and the \StateAggregateMetadata\ parameter from the \load\ method. Additionally, \SnapshotStrategy\ implementations now receive a \StateEventExchange\ instead of a \DomainEventStream\, allowing strategies like \VersionOffsetSnapshotStrategy\ to access the aggregate state directly. The \SimpleSnapshotStrategy\ has been simplified to save a snapshot for every state event, while \VersionOffsetSnapshotStrategy\ creates snapshots based on a configurable version offset. The \InMemorySnapshotRepository\ is now a deprecated alias for \InMemorySnapshotStore\.

wow-core/src/main/kotlin/me/ahoo/wow/eventsourcing/snapshot · high confidence

The stateless saga execution pipeline has been refactored to use the \CommandGateway\ and \CommandBuilder\ instead of the previous \CommandBus\ and \CommandOptions\ abstractions. \StatelessSagaFunction\ now wraps the delegate function, executes commands via the gateway, and constructs command messages using the \CommandBuilder\ API, which supports header propagation and request ID generation. Additionally, \StatelessSagaDispatcher\ has been updated to extend \CompositeEventDispatcher\ and accept \AggregateSchedulerSupplier\ instead of a raw \Scheduler\ provider, while \StatelessSagaFunctionRegistrar\ has been simplified to use \MessageFunctionRegistrar\ directly. These changes improve the consistency of command handling and message propagation in stateless sagas.

wow-core/src/main/kotlin/me/ahoo/wow/saga/stateless · high confidence

The order API module has been restructured and enriched with new routing and validation features. OrderStatus was moved to the API module and now implements EnumText with localized text. CommandRoute annotations were added to ChangeAddress, PayOrder, ReceiptOrder, and ShipOrder, introducing actions like 'address', 'package', and 'pay' with specific HTTP methods (PUT, POST, PATCH). The CreateOrder command was updated to support complex validation via CommandValidator, requiring a China shipping address. OrderItem was refactored to implement CreateOrderItem and Identifier, and validation annotations were migrated from javax to jakarta.

example/example-api/src/main/kotlin/me/ahoo/wow/example/api/order · medium confidence

The UML design documents in the document/design/uml directory have been updated to reflect a shift in how command execution and feedback are modeled. The 'Send-Command' and 'Command-Feedback' diagrams now use 'WaitPlan' and 'WaitCoordinator' instead of the previous 'WaitStrategy' and 'WaitStrategyRegistrar' concepts, indicating a change in how the system handles waiting for command results. Additionally, new diagrams for 'Compensation-State', 'Event-Compensation-UserCase', and 'Event-Compensation' have been added to document the state flows and user cases for event compensation. The 'Order-Process-Manager' diagram has also been updated to reflect changes in order processing logic, including inventory preparation and shipping states.

document/design/uml · medium confidence

The file AggregateIdSharding.kt, which contained the AggregateIdSharding interface, SingleAggregateIdSharding, CosIdShardingDecorator, and the deprecated CosIdAggregateIdSharding class, has been removed. This eliminates the older sharding logic in favor of the updated sharding architecture.

wow-core/src/main/kotlin/me/ahoo/wow/sharding · high confidence

The \AggregateRoutePathSpec\ interface and the \CommandRouteMetadata\ and \CommandRouteMetadataParser\ classes have been removed from the \wow-core\ module. This change eliminates the previous mechanism for parsing command route metadata and generating aggregate route paths, indicating a shift in how command routing and path resolution are handled within the framework.

wow-core/src/main/kotlin/me/ahoo/wow/route · high confidence

The \CommandAggregateMetadata\ and \NamedAggregateGetter\ classes in the \wow-core\ modeling metadata package have been removed. This change eliminates legacy metadata handling for command aggregates and named aggregate resolution, likely as part of a broader refactoring of the command processing architecture.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/matedata · high confidence

The example bounded context has been renamed from 'OrderBoundedContext' to 'ExampleBoundedContext' and moved from the 'order' sub-package to the root 'me.ahoo.wow.example.domain' package. This change updates the associated service name to 'ExampleService', reflecting a shift from an order-specific context to a more generic example context.

example/example-domain/src/main/kotlin/me/ahoo/wow/example/domain · medium confidence

The command dispatcher classes have been moved from the \me.ahoo.wow.modeling.command\ package to \me.ahoo.wow.modeling.command.dispatcher\. This includes the creation of \AggregateCommandDispatcher\, \AggregateProcessorFilter\, and \CommandHandler\ in the new location. The \CommandDispatcher\ class was also moved and refactored to use \AggregateSchedulerSupplier\ for managing schedulers, and the \CommandHandler\ interface was renamed to \CommandFilter\ with updated filter chain handling. These changes improve the structure and add scheduler support for aggregate dispatchers.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/command/dispatcher · high confidence

The event dispatcher subsystem has been restructured to improve code organization and extensibility. A new \AbstractEventDispatcher\ base class has been introduced to handle common message bus and scheduler logic, from which \EventStreamDispatcher\ and \StateEventDispatcher\ now inherit. The previous \AbstractEventDispatcher\ has been renamed to \AbstractAggregateEventDispatcher\ to better reflect its role as the base for aggregate-specific dispatchers like \AggregateEventDispatcher\ and \AggregateStateEventDispatcher\. Additionally, a \CompositeEventDispatcher\ has been added to coordinate both event stream and state event processing, while a \DomainEventDispatcher\ provides a convenient wrapper for domain event handling. This refactoring separates concerns between general dispatching logic and aggregate-specific processing, making the event handling pipeline more modular and easier to extend.

wow-core/src/main/kotlin/me/ahoo/wow/event/dispatcher · high confidence

The snapshot-related dispatcher components have been reorganized into a new 'dispatcher' sub-package. A new AggregateSnapshotDispatcher class handles state event exchanges for specific aggregates, while the existing SnapshotDispatcher and SnapshotHandler have been moved and adapted to work with StateEventExchange instead of EventStreamExchange. A new SnapshotFunctionFilter has been added to the dispatcher chain, and the dispatcher now utilizes a scheduler supplier for managing schedulers per aggregate.

wow-core/src/main/kotlin/me/ahoo/wow/eventsourcing/snapshot/dispatcher · medium confidence

The webhook notification system now uses a new \TemplateEngine\ to generate Markdown-formatted messages for compensation events, replacing the previous JTE-based approach. This change introduces support for rendering detailed status information, including error codes, messages, retry states, and quick navigation links for dashboard access. The \QuickNavigation\ utility is added to generate clickable links to specific execution states in the dashboard.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/webhook · medium confidence

The system now uses a new \SnapshotFindNextRetry\ repository to identify the next retryable failed execution states. This replaces the previous \MongoExecutionFailedQuery\ approach, utilizing the \SnapshotQueryService\ and \nestedState\ DSL to query for states that are recoverable, retryable, and due for retry or timeout.

compensation/wow-compensation-server/src/main/kotlin/me/ahoo/wow/compensation/server/failed · medium confidence

The legacy \AggregateAnnotationParser\ and \OrderComparator\ objects have been removed and replaced with new \AnnotationPropertyAccessorParser\ and \SortedByOrder\ utilities. This introduces a modern, Kotlin-centric approach to parsing annotations like \@AggregateId\, \@AggregateName\, and \@StaticTenantId\ using Kotlin reflection (\KProperty1\, \KClass\) rather than Java reflection. Additionally, the old \OrderComparator\ has been superseded by the \sortedByOrder()\ extension function, which provides more robust sorting of components based on \@Order\ annotations and dependency resolution.

wow-core/src/main/kotlin/me/ahoo/wow/annotation · high confidence

The repository introduces new agent and Claude.md files to guide development workflows and tooling. The root README files (English and Chinese) are significantly restructured to feature a logo, updated badges, a quick-start template button, and a 'Why Wow?' section explaining the framework's value proposition. The .editorconfig is updated to enforce Kotlin import-on-demand rules. The .gitignore is expanded to exclude IDE, build, and cache artifacts. The codecov.yml raises the default coverage target to 80% and excludes specific test and API modules. The Gradle wrapper scripts (gradlew, gradlew.bat) are updated to use the -jar flag for the wrapper JAR and include SPDX headers. Finally, the renovate.json is replaced with a comprehensive configuration that groups dependency updates by ecosystem (Spring, Kotlin, OpenTelemetry, React, Vite, etc.).

(repo-wide) · high confidence

The compiler's metadata resolution logic has been reorganized into a new 'metadata' package, with the primary change being the introduction of a new 'CommandAggregateRootResolver' that extracts command and event metadata from aggregate roots. This resolver now handles command routing and event generation, while the 'BoundedContextResolver' has been updated to support a new 'description' property and 'tenantId' for aggregates. Additionally, the 'MetadataSymbolProcessor' now uses a custom Jackson ObjectMapper configuration to ensure safe and pretty-printed JSON serialization of the generated metadata, replacing the previous 'asPrettyJson' approach.

wow-compiler/src/main/kotlin/me/ahoo/wow/compiler/metadata · medium confidence

The Spring module has been refactored to support auto-registration of query services and updated dispatcher lifecycle management. New registrars have been introduced: \EventStreamQueryServiceRegistrar\ and \SnapshotQueryServiceRegistrar\ enable automatic registration of corresponding query services within the Spring context. The \PrepareKeyFactoryBean\ has been added to handle \PrepareKey\ instantiation. Meanwhile, the \MessageDispatcherLauncher\ and its subclasses (e.g., \CommandDispatcherLauncher\, \SnapshotDispatcherLauncher\) now accept a \shutdownTimeout\ parameter and use \stop()\ instead of \close()\, ensuring graceful shutdowns. Additionally, Spring-specific stereotype annotations (e.g., \@EventProcessor\, \@Saga\) have been removed in favor of API-level annotations, and the \AutoRegistrar\ logic has been updated to use \KotlinLogging\ instead of \slf4j\. Tests have been added for \MessageDispatcherLauncher\ and \SpringServiceProvider\ to cover these behavioral changes.

wow-spring · high confidence

The logic for converting class names to snake\_case has been refactored to use a shared \pascalToSnake\ function from \NamingConverter\, replacing the previous direct call to \NamingConverter.PASCAL\_TO\_SNAKE.convert\. Additionally, extension functions for converting class names to resource names have been renamed from \asName\ to \toName\, and a new \toName\ extension for \KClass\ has been added to support Kotlin reflection types.

wow-core/src/main/kotlin/me/ahoo/wow/naming/annotation · medium confidence

The StatelessSagaMetadataParser has been updated to recognize and process the new OnStateEvent annotation alongside the existing OnEvent annotation. This change allows stateless sagas to react to state events in addition to domain events, expanding the types of events that can trigger saga processing logic.

wow-core/src/main/kotlin/me/ahoo/wow/saga/annotation · high confidence

The \AggregateMetadataParser\ now supports \AfterCommand\ annotations, allowing users to register post-command execution functions that run after a command is processed. The parser has been refactored to use Kotlin reflection (\KFunction\, \KProperty1\) instead of Java reflection (\Method\, \Field\), enabling more robust metadata extraction. Additionally, the \StateAggregateMetadataParser\ has been updated to support constructors with up to two String parameters (id and tenantId) and uses Kotlin reflection for property access. The \AggregateMetadata\ now includes a \mountedCommands\ field derived from the \AggregateRoot\ annotation, and the \afterCommandFunctionRegistry\ is sorted by order.

wow-core/src/main/kotlin/me/ahoo/wow/modeling/annotation · medium confidence

The end-to-end benchmark results for the framework have been updated, providing a new baseline for performance metrics such as operations per second and latency across various scenarios.

wow-benchmarks/results/baselines · medium confidence

Add contract tests for FunctionInvokerAccessorSupport; Added Java compatibility test fixtures; Added and restructured tests for the order domain; Added concurrent sink tests; Added contract tests for FunctionInvoker; Added contract tests for command and event bus implementations; Added contract tests for eventsourcing components; Added contract tests for mock event and snapshot stores; Added test DSL marker and builder interfaces for the Wow testing framework; Added test coverage for StatelessSagaMetadataParser; Added test coverage for the FailedDetails component; Added test for BI script configuration; Added test for failed state retry logic; Added test utilities and mock classes for compiler testing; Added test utility for validating commands; Added tests for PrepareKey and its proxy/metadata handling; Added tests for RetrySpec functionality; Added tests for SimpleServiceProvider; Added tests for aggregate metadata generation; Added tests for container diagnostics, image configuration, and authentication waiters; Added tests for domain event function filtering and event stream dispatcher lifecycle; Added tests for event sourcing components; Added tests for function invoker, reflection, and reactor checkpointing; Added tests for metadata caching, metadata value exposure, and state aggregate serialization; Added tests for reflection annotation scanning and merging; Added tests for the MetadataSymbolProcessor; Added tests for the QuerySymbolProcessor; Added unit tests for AggregateSchedulerSupplier; Added unit tests for Cart aggregate and CartSaga; Added unit tests for SendStateEventFilter; Added unit tests for Wow ID generation and registration; Added unit tests for WowMetadata configuration and search logic; Added unit tests for cache refresher and source components; Added unit tests for command dispatcher lifecycle and domain event stream filtering; Added unit tests for command gateway API, validation, and idempotency logic; Added unit tests for command message factory and builder components; Added unit tests for command modeling components; Added unit tests for command wait coordination and notification; Added unit tests for compensation matching and event compensation support; Added unit tests for domain event handling and dispatching; Added unit tests for event compensation logic; Added unit tests for event type registry and state JSON record serialization; Added unit tests for exception handling and recovery logic; Added unit tests for message bus and header implementations; Added unit tests for message exchange acknowledgment and retry filter behavior; Added unit tests for message propagation components; Added unit tests for metrics decorators; Added unit tests for reactor lifecycle, checkpointing, and scheduler behavior; Added unit tests for snapshotting components; Added unit tests for stateless saga function execution; Added unit tests for the App component; Added unit tests for the Failed compensation dashboard features; Added unit tests for the webhook TemplateEngine; Added unit tests for wow-core modeling metadata; Comprehensive JSON serialization tests for commands, events, and failure modes; Expanded test coverage for aggregate modeling components; Expanded test coverage for idempotency checkers; Migrate Wow-IT test fixtures to integration test layer; Moved command and projection tests to contract test layer; New test utilities for aggregates and sagas; New unit tests for state aggregate lifecycle and identity; Refactor aggregate test DSL with new stage interfaces and implementations; Refactor stateless saga test DSL with new stage interfaces; Removed obsolete test files for method accessors; Restructured and modernized cart domain tests; Standardize test assertions and naming conventions in wow-core naming module; Stateless saga DSL refactored into separate DSL files with dynamic test support; TCK test infrastructure refactored with new container and query service specs; Test coverage for after-command function parsing and sorting; Updated ConstructorAccessor and InjectableObjectFactory tests; Updated EventUpgraderFactoryTest to use custom assertion library; Updated command metadata parsing tests to use AssertJ; Updated service provider configurations for error handling components; Updated test ID generator to use KotlinLogging; Updated test suite for ProjectionProcessorMetadataParser; Updated test suite for annotation processing and ordering; Updated test suite for event metadata and processor parsing; Updated test suite for message function metadata and registration; Updated tests for projection function registration; Updated unit tests for property accessor components.

The project's Spring Boot dependency has been updated to version 3.5.11, ensuring compatibility with the latest features and fixes in the Spring Boot ecosystem.

(dependencies) · high confidence

The Gradle wrapper has been upgraded from version 8.1.1 to 9.6.1. This update includes new configuration properties for build reliability, specifically adding retry logic with a 500ms backoff and enabling URL validation, which may affect how Gradle downloads and validates its distribution files.

gradle · 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 58.

• Code Health 95
• Architecture 97
• Maturity 75
• Readiness 45
• Security 56
• Domain Modelling 74

• 300 commits — 222 feature/other, 78 fixes

• compensation/dashboard — 46 commits
• wow-core/src — 36 commits
• (root) — 34 commits
• documentation/docs — 30 commits
• gradle/libs.versions.toml — 26 commits
• wow-webflux/src — 21 commits
• .github/workflows — 19 commits
• docs/superpowers — 15 commits
• wow-benchmarks/src — 11 commits
• wow-benchmarks/results — 7 commits
• documentation/package.json — 6 commits
• skills/wow — 5 commits
• wow-spring-boot-starter/src — 4 commits
• test/wow-tck — 3 commits
• wow-bi/src — 3 commits
• wow-mongo/src — 3 commits
• wow-openapi/src — 3 commits
• wow-schema/src — 3 commits
• compensation/wow-compensation-server — 2 commits
• documentation/pnpm-lock.yaml — 2 commits

• fix: Revert "chore(deps): update pnpm/action-setup action to v6"
• fix: Revert "feat(config): update API base URL and integrate Monaco editor loader"
• fix: feat(benchmark): fix bugs, unify config, add new benchmarks, and build analysis system (#2663)
• fix: fix(core): correct event store version validation messages and enhance retry logging
• fix: fix(core): filter snapshot scans by aggregate (#2648)
• fix: fix(core): harden accessor edge cases (#2655)
• fix: fix(core): harden local bus subscriptions (#2660)
• fix: fix(core): harden reactive dispatcher lifecycle (#2657)
• fix: fix(core): isolate copied event headers (#2647)
• fix: fix(core): make metrics decoration idempotent (#2651)
• fix: fix(core): normalize aggregate id generator keys (#2652)
• fix: fix(core): preserve async command event ordering (#2650)
• fix: fix(core): require scope prefix boundary (#2653)
• fix: fix(core): resolve exception handlers by type hierarchy (#2649)
• fix: fix(core): route local wait signals by command id (#2654)
• fix: fix(dashboard): preserve fetcher parameter decorators (#2656)
• fix: fix(deps) Lock file maintenance lock files (#2760)
• fix: fix(deps) Lock file maintenance lock files (#2763)
• fix: fix(deps) Update @ant-design/icons to ^6.3.2 (#2739)
• fix: fix(deps) Update @vitejs/plugin-react to v6.0.3 (#2722)
• …and 280 more

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

Ahoo-Wang/Wow 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.