8.85.0 release (2026-06-17)

Total recipe count: 4463

info

This changelog only shows what recipes have been added, removed, or changed. OpenRewrite may do releases that do not include these types of changes. To see these changes, please go to the releases page.

Corresponding CLI version

• CLI version v4.3.2

New Recipes

• ai.timefold.solver.migration.fork.TimefoldChangeDependencies: Migrate all Maven and Gradle groupIds and artifactIds from OptaPlanner to Timefold.
• ai.timefold.solver.migration.v8.AsConstraintRecipe: Use penalize().asConstraint() and reward().asConstraint() instead of the deprecated penalize() and reward() methods.
• ai.timefold.solver.migration.v8.ConstraintRefRecipe: Use getConstraintRef() instead of getConstraintId() et al.
• ai.timefold.solver.migration.v8.EnvironmentMigrationRecipe: Use non-deprecated environment constants.
• ai.timefold.solver.migration.v8.NullableRecipe: Removes references to null vars and replace them with unassigned values.
• ai.timefold.solver.migration.v8.RemoveConstraintPackageRecipe: Remove the use of constraint package from asConstraint(package, name).
• ai.timefold.solver.migration.v8.ScoreGettersRecipe: Use score() instead of getScore() on Score implementations.
• ai.timefold.solver.migration.v8.ScoreManagerMethodsRecipe: Use explain() and update() instead of explainScore(), updateScore() and getSummary().
• ai.timefold.solver.migration.v8.SingleConstraintAssertionMethodsRecipe: Use penalizesBy/rewardsWith(String, int) instead of penalizesBy/rewardsWith(int, String) on SingleConstraintAssertion tests.
• ai.timefold.solver.migration.v8.SolutionManagerRecommendAssignmentRecipe: Use recommendAssignment() instead of recommendFit().
• ai.timefold.solver.migration.v8.SolverManagerBuilderRecipe: Use solveBuilder() instead of deprecated solve methods on SolveManager.
• ai.timefold.solver.migration.v8.SortingMigrationRecipe: Use non-deprecated related sorting fields and methods.
• io.axoniq.framework.migration.Axon4ToAxoniq5AxonServerConnector: Relocates the Axon Server connector from org.axonframework.axonserver.connector to io.axoniq.framework.axonserver.connector. The connector now lives in the Axoniq commercial offering (io.axoniq.framework:axon-server-connector). Class names are mostly preserved.
• io.axoniq.framework.migration.Axon4ToAxoniq5Bom: Replaces the imported org.axonframework:axon-bom (AF4) or org.axonframework:axon-framework-bom (free AF5) in <dependencyManagement> with the Axoniq Framework 5 commercial BOM io.axoniq.framework:axoniq-framework-bom.
• io.axoniq.framework.migration.Axon4ToAxoniq5DeadLetter: Relocates the Sequenced Dead-Letter Queue (DLQ) types from the open-source axon-messaging module to the Axoniq commercial axoniq-dead-letter module (io.axoniq.framework:axoniq-dead-letter). Class names — including SequencedDeadLetterQueue, JpaSequencedDeadLetterQueue, JdbcSequencedDeadLetterQueue, DeadLetteredEventProcessingTask, EnqueuePolicy, Decisions, ThrowableCause — are preserved.
• io.axoniq.framework.migration.Axon4ToAxoniq5DistributedMessaging: Relocates the distributed command-bus components (DistributedCommandBus, CommandBusConnector) from the AF4 open-source axon-messaging module into the Axoniq commercial axoniq-distributed-messaging module (io.axoniq.framework.messaging.commandhandling.distributed). Each AF4 fully-qualified name is mapped directly to its final Axoniq location, so this recipe is order-independent relative to the open-source messaging package rename.
• io.axoniq.framework.migration.Axon4ToAxoniq5EventStreaming: Placeholder. The Axoniq event streaming module (io.axoniq.framework:axoniq-event-streaming) consolidates multi-stream event consumption that lived in MultiStreamableMessageSource (available since Axon Framework 4.2) into a dedicated module in Axoniq Framework 5. AF4 applications using MultiStreamableMessageSource should migrate to axoniq-event-streaming once they adopt Axoniq Framework 5; this recipe will gain class-level mappings as that migration becomes deterministic.
• io.axoniq.framework.migration.Axon4ToAxoniq5SpringBoot: Swaps the Spring Boot starter dependency to the Axoniq commercial variant (io.axoniq.framework:axoniq-spring-boot-starter). Accepts both the AF4 raw coordinate (org.axonframework:axon-spring-boot-starter) and the post-Axon4ToAxon5SpringBootExtension coordinate (org.axonframework.extensions.spring:axon-spring-boot-starter). Class-level mappings for the Axoniq autoconfig package io.axoniq.framework.springboot.* are not yet implemented.
• io.axoniq.framework.migration.Axon4ToAxoniq5Testcontainer: Relocates the Axon Server Testcontainer types from the AF4 axon-test package org.axonframework.test.server to the dedicated Axoniq commercial artifact io.axoniq.framework:axoniq-testcontainer under io.axoniq.framework.testcontainer. The Enterprise (AxonServerEEContainer) and Standard (AxonServerSEContainer) edition variants both collapse into the unified AxonServerContainer in Axoniq 5.
• io.axoniq.framework.migration.UpgradeAxon4ToAxoniq5: Migrates an Axon Framework 4.x application to Axoniq Framework 5 (commercial). Composes UpgradeAxon4ToAxon5 (the free leg) and then layers commercial-only migrations: BOM swap to io.axoniq.framework:axoniq-framework-bom, Spring Boot starter swap to io.axoniq.framework:axoniq-spring-boot-starter, source rewrites and Maven adds for Axon Server connector, sequenced dead-letter queue, and distributed messaging.
• io.quarkus.updates.camel.camel420.CamelQuarkusMigrationRecipe: Migrates camel 4.18 Quarkus application to camel 4.20.
• io.quarkus.updates.core.quarkus324.MigrateFromDefaultUniqueDelegate:
• io.quarkus.updates.core.quarkus324.MigrateFromEmptyInterceptor: Replace extends EmptyInterceptor with implements Interceptor, Serializable as EmptyInterceptor was removed in Hibernate ORM 7.
• io.quarkus.updates.core.quarkus324.MigrateFromHibernateOrmEmptyInterceptor:
• io.quarkus.updates.core.quarkus324.MigrateFromHibernateOrmQueryHints:
• io.quarkus.updates.core.quarkus324.MigrateFromHibernateValidatorNotBlank:
• io.quarkus.updates.core.quarkus324.MigrateFromIndexColumn:
• io.quarkus.updates.core.quarkus337.PanacheNextRelocations:
• org.axonframework.migration.AddAxonTestFixtureTearDown: Adds an @AfterEach tearDown() method calling stop() on the AxonTestFixture field, when the test class has such a field but no existing @AfterEach method (and no method named tearDown). Pairs with MigrateAggregateTestFixtureSetup which produces the field; the tear-down step was previously left for manual migration. Java sources only.
• org.axonframework.migration.AddCommandAnnotation: Scans @CommandHandler methods and annotates their command parameter types with @Command. Also migrates @RoutingKey on a field to @Command(routingKey = "fieldName") on the class, removing the @RoutingKey field annotation.
• org.axonframework.migration.AddEntityCreatorAnnotation: Annotates existing no-arg constructors with @EntityCreator for any class annotated with @EventSourcedEntity or the Spring @EventSourced stereotype. Required by AF5 — the framework uses this annotation to instantiate the entity before applying events. Idempotent: skips constructors that are already annotated.
• org.axonframework.migration.AddEventAnnotation: Scans @EventSourcingHandler methods and annotates their event parameter types with @Event. Migrates @Revision("x") on the class to @Event(version = "x"), removing the now-obsolete @Revision annotation.
• org.axonframework.migration.AddEventTagAnnotation: Scans event-sourced entity classes for their @AggregateIdentifier field and the event types used in @EventSourcingHandler methods, then annotates the corresponding field in each event class with @EventTag(key = <EntitySimpleName>).
• org.axonframework.migration.AnnotateObsoleteSequencingPolicyProperty: Inserts a one-line # TODO(axon4to5): ... comment above any axon.eventhandling.processors.<group>.sequencing-policy entry in application.properties / application.yml. AF5 moves the decision onto the handler class via @SequencingPolicy; deleting the property here would race the per-construct skill that drives the source-side annotation, so this recipe only annotates. Idempotent.
• org.axonframework.migration.Axon4ToAxon5AmqpExtension: Placeholder for the AMQP extension migration. The AMQP extension lives at org.axonframework.extensions.amqp in AF4 and does not yet have a finalized Axon Framework 5 equivalent. Update this recipe once the AF5 AMQP integration ships.
• org.axonframework.migration.Axon4ToAxon5Bom: Renames the imported org.axonframework:axon-bom BOM in <dependencyManagement> to org.axonframework:axon-framework-bom and pins the imported version to the current Axon Framework 5 release. The BOM artifactId changed between Axon Framework 4 and Axon Framework 5; the groupId is unchanged.
• org.axonframework.migration.Axon4ToAxon5CdiExtension: Placeholder for the CDI extension migration. The extension lives at org.axonframework.extensions.cdi in AF4 and does not yet have a finalized Axon Framework 5 equivalent. Update this recipe once the AF5 CDI integration ships.
• org.axonframework.migration.Axon4ToAxon5Common: Migrates org.axonframework.config to org.axonframework.common.configuration, renames ConfigurerModule to ConfigurationEnhancer, ModuleConfiguration to Module, LifecycleOperations to LifecycleRegistry, relocates EventProcessingConfigurer under the messaging.eventhandling namespace, and swaps @ProcessingGroup for the AF5 @Namespace annotation.
• org.axonframework.migration.Axon4ToAxon5Conversion: Migrates the Serializer-based org.axonframework.serialization namespace to the new Converter-based org.axonframework.conversion namespace. Note: this is a package rename; concrete renames such as JacksonSerializer to JacksonConverter are NOT applied here and must be handled separately.
• org.axonframework.migration.Axon4ToAxon5EventSourcing: Relocates the @EventSourcingHandler annotation into eventsourcing.annotation, relocates Snapshotter into the new eventsourcing.snapshot.api API package, ensures the org.axonframework:axon-eventsourcing dependency is present when the app uses event-sourcing types (the AF5 Spring Boot starter no longer pulls it transitively, so apps not using the BOM need it added explicitly — it transitively brings axon-modelling and axon-messaging), and applies the source-level aggregate→entity rewrites — annotating no-arg constructors with the now-mandatory @EntityCreator and replacing AggregateLifecycle.apply(...) with an injected EventAppender#append(...).
• org.axonframework.migration.Axon4ToAxon5JGroupsExtension: Placeholder for the JGroups extension migration. The JGroups extension at org.axonframework.extensions.jgroups provided distributed command bus routing in AF4. In Axon Framework 5 the distributed command bus has moved into the AxonIQ commercial offering (io.axoniq.framework:axoniq-distributed-messaging). Code using JGroupsConnector must be replaced with the AxonIQ commercial distributed messaging APIs.
• org.axonframework.migration.Axon4ToAxon5KafkaExtension: Placeholder for the Kafka extension migration. The Kafka extension lives at org.axonframework.extensions.kafka in AF4 and does not yet have a finalized Axon Framework 5 equivalent. Update this recipe once the AF5 Kafka integration ships.
• org.axonframework.migration.Axon4ToAxon5Messaging: Migrates the messaging core (command, event, query handling) from org.axonframework.{command,event,query}handling into the org.axonframework.messaging.* namespace, relocates handler & interceptor annotations into their .annotation.* subpackages, renames EventBus to EventSink, fixes MetaData casing to Metadata, relocates the top-level messaging API (Message, Metadata, UnitOfWork, MessageHandlerInterceptor, MessageHandlerInterceptorChain, correlation.*) into messaging.core.*, moves the sequencing policy package out of eventhandling.async into messaging.core.sequencing, relocates tokenstore and the replay/reset annotations under their AF5 subpackages, and moves QueryGateway into its own gateway subpackage.
• org.axonframework.migration.Axon4ToAxon5MetricsDropwizardExtension: Relocates org.axonframework.metrics to org.axonframework.extension.metrics.dropwizard, reflecting the move from a flat metrics namespace to a per-provider layout under extension.metrics.*.
• org.axonframework.migration.Axon4ToAxon5MetricsMicrometerExtension: Relocates org.axonframework.micrometer to org.axonframework.extension.metrics.micrometer, reflecting the move into the per-provider extension.metrics.* layout.
• org.axonframework.migration.Axon4ToAxon5Modelling: Migrates the modelling layer from the aggregate vocabulary to the entity vocabulary: relocates org.axonframework.modelling.command to org.axonframework.modelling.entity, renames TargetAggregateIdentifier to TargetEntityId, AggregateMember to EntityMember, Repository into modelling.repository, and CommandTargetResolver to EntityIdResolver. Strips AF4-only modelling annotations (@AggregateIdentifier, @CreationPolicy) that have no AF5 successor — id resolution moved onto commands via @TargetEntityId, and the AF4 creation-policy semantics map onto static command handlers in AF5 (a manual rewrite the recipe cannot infer beyond removing the annotation itself).
• org.axonframework.migration.Axon4ToAxon5MongoExtension: Placeholder for the Mongo extension migration. The Mongo extension lives at org.axonframework.extensions.mongo in AF4 and does not yet have a finalized Axon Framework 5 equivalent. Update this recipe once the AF5 Mongo integration ships.
• org.axonframework.migration.Axon4ToAxon5MultitenancyExtension: Placeholder for the Multitenancy extension migration. The extension lives at org.axonframework.extensions.multitenancy in AF4 and does not yet have a finalized Axon Framework 5 equivalent. Update this recipe once the AF5 multitenancy story ships.
• org.axonframework.migration.Axon4ToAxon5QueryResponseTypes: On two-argument queryGateway.query(payload, ResponseType) calls, unwraps the AF4 ResponseTypes.instanceOf(...) / optionalInstanceOf(...) / multipleInstancesOf(...) wrapper to the plain Class<R> form AF5 expects, and renames query(payload, multipleInstancesOf(R.class)) to queryMany(payload, R.class). Three-argument query(String, Object, ...) forms, subscriptionQuery(...), and streamingQuery(...) are left untouched so the per-construct migration skill keeps the AF4 fingerprints it needs for design decisions. Removes ResponseType / ResponseTypes imports only when no references remain.
• org.axonframework.migration.Axon4ToAxon5ReactorExtension: Relocates org.axonframework.extensions.reactor.* to org.axonframework.extension.reactor.* (singular extension) and inserts the messaging. segment in front of the commandhandling, eventhandling, and queryhandling subpackages. The bare extensions.reactor.messaging.* package (which holds ReactorMessageDispatchInterceptor and the interceptor chain) is moved under extension.reactor.messaging.core.*.
• org.axonframework.migration.Axon4ToAxon5SpringAotExtension: The org.axonframework.extensions.spring-aot:axon-spring-aot extension has no Axon Framework 5 port. Removes the dependency so the project compiles against AF5. Projects that need Spring AOT / native-image support against AF5 must reintroduce equivalent functionality manually — there is no drop-in replacement.
• org.axonframework.migration.Axon4ToAxon5SpringBootActuatorExtension: Relocates org.axonframework.actuator to org.axonframework.extension.springboot.actuator. The Actuator support is now nested under the Spring Boot extension namespace.
• org.axonframework.migration.Axon4ToAxon5SpringBootExtension: Relocates org.axonframework.springboot to org.axonframework.extension.springboot, matching the Maven groupId move to org.axonframework.extensions.spring. Covers both the autoconfigure and starter artifacts (apps depend on the starter, which transitively pulls autoconfigure). Also rewrites Spring Boot configuration property keys whose binding class moved or was renamed in AF5.
• org.axonframework.migration.Axon4ToAxon5SpringCloudExtension: Placeholder for the Spring Cloud extension migration. The Spring Cloud extension at org.axonframework.extensions.springcloud provided distributed command bus routing in AF4. In Axon Framework 5 the distributed command bus has moved into the AxonIQ commercial offering (io.axoniq.framework:axoniq-distributed-messaging). Code using SpringCloudCommandRouter must be replaced with the AxonIQ commercial distributed messaging APIs.
• org.axonframework.migration.Axon4ToAxon5SpringExtension: Relocates org.axonframework.spring to org.axonframework.extension.spring and renames the Spring stereotype @Aggregate to @EventSourced. The stereotype rename is mapped from both the AF4 location and the post-package- move location, so the recipe is order-independent.
• org.axonframework.migration.Axon4ToAxon5Test: Renames AggregateTestFixture and SagaTestFixture to the unified AxonTestFixture introduced in Axon Framework 5, and rewrites AF4-style flat fixture call chains (fixture.given(...).when(...).expectEvents(...)) to the AF5 fluent given/when/then API (fixture.given().events(...).when().command(...).then().events(...)). Also generates an @AfterEach tearDown() calling fixture.stop() on test classes that declare an AxonTestFixture field but have no existing @AfterEach. Targets the axon-test Maven artifact. Hamcrest matcher conversions and Kotlin @AfterEach insertion remain manual.
• org.axonframework.migration.Axon4ToAxon5TracingOpenTelemetryExtension: Placeholder for the OpenTelemetry tracing extension migration. Revisioning of the distributed tracing extension for Axon Framework 5 is slated for a later release (see issue #3594). Update this recipe once the AF5 OpenTelemetry tracing integration ships.
• org.axonframework.migration.Axon4ToAxon5TracingOpenTracingExtension: Placeholder. The OpenTracing tracing extension at org.axonframework.extensions.tracing is superseded by the OpenTelemetry tracing extension in Axon Framework 5 (see Axon4ToAxon5TracingOpenTelemetryExtension). Code using OpenTracing must be migrated to OpenTelemetry manually.
• org.axonframework.migration.ConfigureEventSourcedAnnotation: Adds explicit tagKey = <EntitySimpleName> and idType = <ResolvedType>.class to @EventSourced annotations that have no tagKey set. The tagKey is derived from the class simple name (matching the AF5 default). The idType is deduced from the type of the field annotated with @AggregateIdentifier in AF4. When that field is absent (e.g. POJO aggregate without an explicit identifier field) the idType falls back to Object.class and is flagged with a TODO(axon4to5): comment.
• org.axonframework.migration.ConvertCommandHandlerConstructorToCompanionObject: Rewrites Kotlin @CommandHandler constructor(...) declarations into companion object { @JvmStatic @CommandHandler fun handle(...) } on the same class, matching the AF5 contract where @CommandHandler no longer targets constructors. Parameter list and method body are preserved.
• org.axonframework.migration.ConvertCommandHandlerConstructorToStaticMethod: Rewrites Axon Framework 4 @CommandHandler constructors into public static void handle(...) methods, matching the AF5 contract where @CommandHandler no longer targets constructors. Parameter list and method body are preserved.
• org.axonframework.migration.MigrateAggregateTestFixtureSetup: Rewrites new AggregateTestFixture<X>(X.class) (the AF4 aggregate-fixture constructor) to AF5's AxonTestFixture.with(EventSourcingConfigurer.create().registerEntity(EventSourcedEntityModule.autodetected(<IdType>.class, X.class))). The aggregate type X is read from the class-literal constructor argument; the id type is looked up via the cross-recipe map populated by AddEventTagAnnotation (while @AggregateIdentifier is still on the source). Only matches the AF4 AggregateTestFixture FQN — SagaTestFixture setups are left for manual migration.
• org.axonframework.migration.MigrateAxonTestFixtureFluentApi: Rewrites the flat AF4 fixture.given(...).when(...).expectEvents(...) call shape to the AF5 fluent fixture.given().events(...).when().command(...).then().events(...) shape, including the leaf-method renames (expectNoEvents → noEvents, expectSuccessfulHandlerExecution → success, expectException + expectExceptionMessage → single exception(cls, msg), etc.). The fixture setup migration (constructor → AxonTestFixture.with(configurer), @AfterEach stop()) and Hamcrest matcher conversions stay manual.
• org.axonframework.migration.MigrateCommandGatewayInEventHandler: Inside every @EventHandler method in the class, rewrites calls of the form commandGateway.send(...) / commandGateway.sendAndWait(...) (where commandGateway is a class-level CommandGateway field) to commandDispatcher.send(...) on a method-level CommandDispatcher parameter — adding the parameter when missing. For void handlers whose body is a single dispatch expression or a single try/catch with one dispatch per branch, the return type is widened to CompletableFuture<?> and the dispatch is converted to return ... .getResultMessage();. Once no other references to the gateway field remain, the field, its constructor parameter, and the matching assignment are removed.
• org.axonframework.migration.MigrateKotlinDslBomImport: Swaps the groupId:artifactId prefix of a Spring Dependency Management mavenBom("g:a:${property("...")}") call in a build.gradle.kts script, leaving the ${property(...)} indirection in place. Optionally updates the literal value of the matching extra["..."] declaration so the version follows the new BOM. Targets a gap in gradle.ChangeManagedDependency where the Kotlin string-template variant of property(...) is not recognized.
• org.axonframework.migration.MigrateMessageInterceptorSignatures: Rewrites the method signatures of MessageHandlerInterceptor and MessageDispatchInterceptor implementations to their AF5 shape: handle(UnitOfWork, InterceptorChain) -> Object becomes interceptOnHandle(M, ProcessingContext, MessageHandlerInterceptorChain<M>) -> MessageStream<?> (and similarly for the dispatch interceptor). The method body is left untouched — the dropped unitOfWork / interceptorChain references become compile errors, surfacing every call site that needs review. A class-level // TODO(axon4to5): comment points to the migration path doc. The message type M is read from the implements clause; raw implementations fall back to Message. Runs after the AF4 -> AF5 FQN renames.
• org.axonframework.migration.MigrateSequencingPolicyLambda: Rewrites single-argument SequencingPolicy lambdas (e -> body) to the AF5 shape (e, ctx) -> Optional.ofNullable(body). The AF5 SequencingPolicy.sequenceIdentifierFor method takes both a message and a ProcessingContext, and returns Optional<Object> instead of a nullable Object. Adds the java.util.Optional import. Leaves block-body lambdas, multi-parameter lambdas, and anonymous inner classes alone — those need manual rewriting since the AF4 method name (getSequenceIdentifierFor) and the AF5 method name (sequenceIdentifierFor) differ.
• org.axonframework.migration.MigrateSnapshotTriggerDefinitionToAnnotation: Replaces AF4 Spring Boot @Bean methods returning SnapshotTriggerDefinition with the AF5 @Snapshotting annotation on the corresponding aggregate class. EventCountSnapshotTriggerDefinition maps to afterEvents; AggregateLoadTimeSnapshotTriggerDefinition maps to afterSourcingTime. Custom implementations leave a TODO comment for manual review.
• org.axonframework.migration.RemoveTypeArguments: Removes the generic type arguments (<...>) from any usage of the configured fully-qualified type. Preserves the underlying type reference and its surrounding context (variables, parameters, return types, generic bounds, etc.).
• org.axonframework.migration.ReplaceAggregateLifecycleApply: Replaces every AggregateLifecycle.apply(X) (statically imported or via the class) with eventAppender.append(X), injecting an EventAppender eventAppender parameter into the enclosing method when one is not already declared. Drops the static apply import once no usages remain.
• org.axonframework.migration.UpgradeAxon4ToAxon5: Migrates an Axon Framework 4.x application to free (Apache 2.0) Axon Framework 5. Bumps the Axon Framework dependency versions, applies per-module rename recipes (one per core framework module), and renames Maven coordinates within the org.axonframework.* namespace. Does NOT touch features dropped from free AF5 (Axon Server, DLQ, DistributedCommandBus) — see UpgradeAxon4ToAxoniq5 for the commercial path.
• org.axonframework.migration.UpgradeJava: Bumps the Java compiler target in pom.xml/build.gradle to the configured LTS (defaults to 21, the Axon Framework 5 minimum). No-op for modules already at or above the target — projects already on a higher Java release are left untouched.
• org.axonframework.migration.UpgradeKotlin: Bumps the org.jetbrains.kotlin:* dependency versions and the kotlin-maven-plugin to the configured Kotlin line (defaults to "2.x", the latest Kotlin 2.x). No-op for modules already at or above the target — the underlying upgrade recipes never downgrade. Rejects targets below Kotlin 2.0.
• org.openrewrite.gradle.gradle9.OneDependencyDeclarationPerStatement: The Gradle Groovy DSL accepts multiple coordinates in a single configuration call (e.g. implementation 'a:b:1.0', 'c:d:2.0'), but the Kotlin DSL does not. Gradle's best practices recommend declaring a single dependency per statement; see the Gradle dependency best practices. This recipe splits multi-coordinate Groovy DSL configuration calls into one call per coordinate. Run this as a cleanup pass before other dependency-aware recipes (e.g. UpgradeDependencyVersion, ChangeDependency, RemoveDependency): those recipes use the GradleDependency trait, which only inspects the first argument of a configuration call. Coordinates in later positions are invisible to them until this recipe reshapes the source into one declaration per statement.
• org.openrewrite.gradle.gradle9.UseMatchingInsteadOfFindAll: Gradle 9.4 deprecates the Groovy DomainObjectCollection.findAll(Closure) overload on containers such as tasks, configurations, and sourceSets. It is replaced by the lazy DomainObjectCollection.matching(Closure), which returns a live collection that only filters elements as they are needed by the build. This recipe only swaps the method name, leaving the closure argument unchanged, rewriting findAll { ... } to matching { ... } when the receiver is a known Gradle container collection.
• org.openrewrite.gradle.gradle9.UseProjectDependencyInsteadOfModuleCoordinates: Gradle 9.3 deprecates depending on the current project by its own group:name:version module coordinates. In Gradle 9.x such a declaration resolves to the project's local outgoing variants, but in Gradle 10 it will instead attempt resolution from a repository. This recipe replaces a dependency declaration whose coordinates match the current project with the equivalent project("<path>") notation. Requires the GradleProject marker (available when parsed by the OpenRewrite Gradle plugin) to know the current project's coordinates and path.
• org.openrewrite.hibernate.MigrateToHypersistenceUtilsHibernate70: This recipe will migrate any existing dependencies on io.hypersistence:hypersistence-utils-hibernate-63 to io.hypersistence:hypersistence-utils-hibernate-70.
• org.openrewrite.hibernate.MigrateToHypersistenceUtilsHibernate71: This recipe will migrate any existing dependencies on io.hypersistence:hypersistence-utils-hibernate-70 to io.hypersistence:hypersistence-utils-hibernate-71.
• org.openrewrite.java.jackson.MigrateFactorySettersToBuilder: In Jackson 3, JsonFactory is immutable and new JsonFactory() is no longer the right entry point: the concrete factory lives at tools.jackson.core.json.JsonFactory and is constructed via JsonFactory.builder()...build(). Configuration methods like enable, disable, configure, setCharacterEscapes, etc. must be called on the builder instead. This recipe migrates setter calls to the builder pattern when safe, or adds TODO comments when automatic migration is not possible.
• org.openrewrite.java.jackson.UpgradeJackson_2_3_ModernizeJacksonCoreFeatures: Jackson 2.10 moved most flag constants out of JsonParser.Feature and JsonGenerator.Feature into the new JsonReadFeature / JsonWriteFeature (for JSON-specific flags) and StreamReadFeature / StreamWriteFeature (for format-agnostic flags). Jackson 3 keeps only the modern locations. This recipe rewrites every legacy constant to its Jackson 2-modern equivalent so the rest of the Jackson 2 → 3 pipeline (in particular the builder migrations) sees flags the modern API will accept.
• org.openrewrite.java.jackson.UseJsonFactoryStaticBuilder: After the Jackson 2 → 3 migration, prefer the concrete static JsonFactory.builder() entry over new JsonFactoryBuilder() so JsonFactory chains read the same way as the format-aligned factories (YAMLFactory.builder(), CBORFactory.builder(), etc.). The reason MigrateFactorySettersToBuilder emits new JsonFactoryBuilder() in the first place is a Jackson 2 quirk — JsonFactory.builder() returned the wildcard TSFBuilder<?, ?> there. In Jackson 3 the static returns a concretely-typed JsonFactoryBuilder, so the constructor form no longer earns its keep.
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes: Replace calls to Logger.isEnabled(Level) with the corresponding SLF4J method calls.
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes$LoggerIsEnabledLevelDebugRecipe: Replace calls to org.apache.logging.log4j.Logger.isEnabled(Level.DEBUG) with org.slf4j.Logger.isDebugEnabled().
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes$LoggerIsEnabledLevelErrorRecipe: Replace calls to org.apache.logging.log4j.Logger.isEnabled(Level.ERROR) (or Level.FATAL) with org.slf4j.Logger.isErrorEnabled(), since SLF4J has no FATAL level.
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes$LoggerIsEnabledLevelInfoRecipe: Replace calls to org.apache.logging.log4j.Logger.isEnabled(Level.INFO) with org.slf4j.Logger.isInfoEnabled().
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes$LoggerIsEnabledLevelTraceRecipe: Replace calls to org.apache.logging.log4j.Logger.isEnabled(Level.TRACE) (or Level.ALL) with org.slf4j.Logger.isTraceEnabled(), since SLF4J has no ALL level.
• org.openrewrite.java.logging.slf4j.Log4j2IsEnabledToSlf4jRecipes$LoggerIsEnabledLevelWarnRecipe: Replace calls to org.apache.logging.log4j.Logger.isEnabled(Level.WARN) with org.slf4j.Logger.isWarnEnabled().
• org.openrewrite.java.migrate.AddMockitoJavaAgentToMavenSurefirePlugin: Adds required configuration to specifically enable the Mockito/Bytebuddy Java agent in the Maven Surefire plugin for Java 21 compatibility.
• org.openrewrite.java.migrate.UpgradeKotlinJvmTargetVersion: Align the Kotlin jvmTarget with the project's Java version so the Kotlin compiler emits bytecode at the same level as javac. Covers kotlin-maven-plugin <jvmTarget> configuration and the Gradle kotlinOptions { jvmTarget = ... } / compilerOptions { jvmTarget = ... } blocks (Groovy and Kotlin DSL). Will not downgrade if the existing Kotlin target is higher than the requested version.
• org.openrewrite.java.spring.boot3.UseRfc6265CookieProcessor: Replace the legacy Tomcat LegacyCookieProcessor with the RFC 6265 compliant Rfc6265CookieProcessor, both in Java references and in the <CookieProcessor className="…"/> attribute of Tomcat configuration files such as context.xml and server.xml. Rfc6265CookieProcessor has been the default cookie processor since Tomcat 8.5; LegacyCookieProcessor exists only for backwards compatibility. RFC 6265 parsing is stricter than the legacy behavior, so review applications relying on legacy cookie handling before applying this recipe.
• org.openrewrite.java.testing.assertj.MigrateAssertionsForClassAndInterfaceTypes: AssertJ deprecated AssertionsForClassTypes and AssertionsForInterfaceTypes in favor of the unified Assertions entry point. This recipe retargets their static methods to Assertions, using assertThatObject where a plain assertThat would otherwise re-bind to a more specific overload and stop compiling (see https://github.com/openrewrite/rewrite-testing-frameworks/issues/664).
• org.openrewrite.java.testing.assertj.MigrateAssertionsForClassTypes: The deprecated AssertionsForClassTypes.assertThat(T) always returns an ObjectAssert, while the unified Assertions.assertThat additionally offers more specific overloads (e.g. for Iterable, Map, Predicate). For arguments matching those overloads, rename assertThat to assertThatObject so that migrating to Assertions keeps returning an ObjectAssert and the code keeps compiling.
• org.openrewrite.java.testing.junit.RemoveJupiterMigrationSupport: Remove JUnit Jupiter migrationsupport.
• org.openrewrite.java.testing.mockito.PowerMockWhiteboxGetInternalStateToJavaReflection: Replace Whitebox.getInternalState(Object, String) with java.lang.reflect.Field access, casting to the declared result type where needed. The field lookup uses getDeclaredField on the target object's class, which differs from PowerMock's class-hierarchy traversal for fields inherited from a superclass.
• org.openrewrite.java.testing.mockito.PowerMockWhiteboxInvokeMethodToJavaReflection: Replace Whitebox.invokeMethod(Object, String, ..) with java.lang.reflect.Method lookup and invoke(). Parameter types are taken from the unambiguously resolved target method, falling back to each argument's compile-time class.
• org.openrewrite.java.testing.mockito.PowerMockWhiteboxSetInternalStateToJavaReflection: Replace Whitebox.setInternalState(Object, String, Object) and Whitebox.setInternalState(Object, String, Object, Class) with java.lang.reflect.Field access. The 3-arg overload looks up the field on the target's class; the 4-arg where-overload uses the supplied Class to resolve fields declared on a superclass.
• org.openrewrite.java.testing.testcontainers.Testcontainers2LocalStack: Testcontainers 2.x removed the nested LocalStackContainer.Service enum and the getEndpointOverride(...) method. Replace LocalStackContainer.Service constants with the equivalent service name strings and getEndpointOverride(service) with getEndpoint(), so code continues to compile against Testcontainers 2.x. This runs while the type is still org.testcontainers.containers.localstack.LocalStackContainer, before it is renamed.
• org.openrewrite.javascript.AddDependency: Add an npm dependency to package.json and regenerate the lock file by running the package manager. If the dependency already exists in any scope, the recipe is a no-op. Not safe to use as a precondition: invokes the package manager and publishes per-project state shared with other dependency recipes.
• org.openrewrite.javascript.ChangeDependency: Renames an npm dependency in package.json and optionally updates its version constraint. After modifying the package.json, the lock file is regenerated by running the package manager. Not safe to use as a precondition: invokes the package manager and publishes per-project state shared with other dependency recipes.
• org.openrewrite.javascript.RemoveDependency: Remove an npm dependency from package.json and regenerate the lock file. If the dependency does not exist in any scope, the recipe is a no-op.
• org.openrewrite.javascript.UpgradeDependencyVersion: Upgrades the version constraint of matching npm dependencies in package.json and regenerates the lock file by running the package manager. Matching is by exact package name or glob pattern. v1 uses simple string inequality for the upgrade check (always overwrites). A future version will use semver to skip already-up-to-date constraints. Not safe to use as a precondition: invokes the package manager and publishes per-project state shared with other dependency recipes.
• org.openrewrite.javascript.UpgradeTransitiveDependencyVersion: Pins or upgrades a transitive npm dependency by adding an override entry to package.json and regenerating the lock file. For npm and Bun, adds to the overrides field; for Yarn, adds to resolutions; for pnpm, adds to pnpm.overrides. The override is idempotent — if the entry already exists with the same version, no change is made. Not safe to use as a precondition: invokes the package manager and publishes per-project state shared with other dependency recipes.
• org.openrewrite.jenkins.MoveJenkinsfileShebangAndReparse: Groovy's Antlr4 parser rejects a #! shebang that is not on the first line of the file, causing the Jenkinsfile to be ingested as a ParseError. This recipe detects that exact failure mode, relocates the shebang to line 1, and re-parses the result with the Groovy parser so downstream recipes have a usable Groovy LST to work with.
• org.openrewrite.openapi.swagger.MigrateApiIgnoreParameterToParameterHidden: Springfox's @ApiIgnore is commonly placed on framework-injected controller parameters (Principal, HttpServletRequest, Pageable, ...). A flat ChangeType to io.swagger.v3.oas.annotations.Hidden produces code that does not compile, because @Hidden cannot target parameters. Convert parameter usages directly to @io.swagger.v3.oas.annotations.Parameter(hidden = true) and leave method/class-level @ApiIgnore for the subsequent ChangeType step.
• org.openrewrite.quarkus.MigrateToQuarkus_v3_33_0: Quarkus update recipes to upgrade your application to 3.33.0.
• org.openrewrite.quarkus.MigrateToQuarkus_v3_37_0: Quarkus update recipes to upgrade your application to 3.37.0.

Removed Recipes

• org.axonframework.migration.UpgradeAxonFramework_4_Jakarta: Migration file to upgrade from an Axon Framework Javax-specific project to Jakarta.
• org.axonframework.migration.UpgradeAxonFramework_4_Javax: Migration file to upgrade an Axon Framework Javax-specific project and remain on Javax.
• org.openrewrite.java.migrate.AddSurefireFailsafeArgLineForMockito: Adds --add-opens JVM arguments required by Mockito and ByteBuddy to the Maven Surefire and Failsafe plugin argLine configuration. Only applied when the project depends on Mockito.
• org.openrewrite.javascript.dependencies.add-dependency: Adds a new dependency to package.json and updates the lock file by running the package manager.
• org.openrewrite.javascript.dependencies.remove-dependency: Removes a dependency from package.json and updates the lock file by running the package manager.
• org.openrewrite.javascript.dependencies.upgrade-dependency-version: Upgrades the version of a direct dependency in package.json and updates the lock file by running the package manager. Either packageName or packagePattern must be specified.
• org.openrewrite.javascript.dependencies.upgrade-transitive-dependency-version: Upgrades the version of a transitive dependency by adding override/resolution entries to package.json and updates the lock file by running the package manager.