Recipes with Data Tables

This doc contains all of the recipes with unique data tables that have been explicitly added by the recipe author. If a recipe contains only the default data tables, it won't be included in this list.

io.moderne.recipe

rewrite-ai

io.moderne.ai.FindAgentsInUse

• Find AI agents configuration files
• Scans codebases to identify usage of AI agents by looking at the agent configuration files present in the repository.

Data tables:

• org.openrewrite.table.SourcesFiles: Source files that matched some criteria.

io.moderne.ai.FindLibrariesInUse

• Find AI libraries in use
• Scans codebases to identify usage of AI services. Detects AI libraries across Java dependencies. Useful for auditing and understanding AI integration patterns.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.

io.moderne.ai.FindModelsInUse

• Find AI models in use
• Scans codebases to identify usage of Large Language Models (LLMs). Detects model references and configuration patterns across Java classes, properties files, YAML configs... Useful for identifying model usage.

Data tables:

• org.openrewrite.table.TextMatches: Lines matching simple text search.

rewrite-angular

org.openrewrite.angular.search.FindAngularComponent

• Find Angular component
• Locates usages of Angular components across the codebase including template elements and other references. If componentName is null, finds all Angular components.

Data tables:

• org.openrewrite.angular.table.AngularComponentUses: Usage locations of Angular components across the codebase.

rewrite-cryptography

io.moderne.cryptography.FindCryptoVulnerabilitiesPipeline

• Find cryptographic vulnerability chains
• Detects cryptographic vulnerabilities that span multiple operations, tracking flow from hardcoded algorithms through key material to encryption operations.

Data tables:

• org.openrewrite.analysis.java.taint.TaintFlowDataTable: Tracks taint flow through pipeline stages, supporting up to 10 stages.

io.moderne.cryptography.FindDirectSSLConfigurationEditing

• Find direct SSL configuration editing
• Detects direct configuration of protocols or cipher suites on SSL objects like SSLSocket, SSLServerSocket, or SSLEngine. This pattern makes SSL/TLS configuration scattered throughout the codebase and prevents centralized security policy management, hindering crypto-agility.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedAlgorithmChoice

• Find hardcoded algorithm choices
• Detects hardcoded algorithm choices in cryptographic operations. Hardcoded algorithms prevent easy migration to stronger or quantum-resistant algorithms when needed. This is a critical crypto-agility issue that makes systems vulnerable to future attacks.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedAlgorithmParameters

• Find hardcoded algorithm-specific parameters
• Detects hardcoded algorithm-specific parameters like RSA public exponents or EC curve parameters. These hardcoded values prevent algorithm agility and may use weak or non-standard parameters that compromise security.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedCertificate

• Find hardcoded certificates
• Detects hardcoded certificates in the code, including certificates that are hardcoded as strings and used to generate X509Certificate instances via CertificateFactory. Hardcoded certificates can lead to security issues when they expire or need to be revoked.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedCiphersuiteChoice

• Find hardcoded cipher suite choices
• Detects hardcoded cipher suite choices used in SSL/TLS configurations. Hardcoded cipher suites prevent easy updates when cipher suites become weak or need to be changed for compliance reasons.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedKeyLength

• Find hardcoded cryptographic key lengths
• Detects hardcoded key lengths used in cryptographic operations like KeyGenerator.init(), KeyPairGenerator.initialize(), RSAKeyGenParameterSpec, and PBEKeySpec. Hardcoded key lengths reduce flexibility and may not meet changing security requirements.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedPrivateKey

• Find hardcoded private keys
• Detects hardcoded private keys in the code, including PEM-encoded keys that flow into KeyFactory.generatePrivate() calls. Hardcoded private keys are a severe security vulnerability as they compromise the entire cryptographic system.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedProtocolChoice

• Find hardcoded SSL/TLS protocol choices
• Detects hardcoded SSL/TLS protocol choices like 'TLSv1.2', 'SSLv3' used in SSLContext.getInstance() and setProtocols() calls. Hardcoded protocols prevent easy updates when protocols become obsolete or insecure.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindHardcodedProviderName

• Find hardcoded cryptographic provider names
• Detects hardcoded cryptographic provider names (like 'BC', 'SunJCE') used in getInstance() calls. Hardcoding provider names reduces portability and can cause issues when the provider is not available on different systems.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindProgrammaticProviderEditing

• Find programmatic security provider editing
• Detects programmatic modifications to the Java Security Provider list through Security.addProvider(), insertProviderAt(), or removeProvider() calls. Modifying providers at runtime makes the security configuration unpredictable and prevents crypto-agility by hardcoding provider dependencies.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindRSAKeyGenParameters

• Find RSA key generation parameters
• Finds RSAKeyGenParameterSpec instantiations and extracts their parameter values into a data table.

Data tables:

• io.moderne.cryptography.table.RSAKeyGenParametersTable: RSAKeyGenParameterSpec instantiations and their configured parameters including key size, public exponent, and optional parameters.

io.moderne.cryptography.FindSSLContextSetDefault

• Find SSLContext.setDefault() usage
• Detects calls to SSLContext.setDefault() which sets the system-wide default SSL context. This is problematic because it affects all SSL/TLS connections in the JVM, potentially overriding security configurations set by other parts of the application or libraries. It also prevents crypto-agility as the configuration becomes global.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.FindSSLSocketParameters

• Find SSL socket configuration parameters
• Finds SSLSocket setter method invocations and extracts their parameter values into a data table.

Data tables:

• io.moderne.cryptography.table.SSLSocketParametersTable: SSLSocket setter method invocations and their configured parameters including cipher suites, protocols, and other SSL/TLS settings.

io.moderne.cryptography.FindSecurityModifications

• Find Security class modifications
• Finds invocations of java.security.Security methods that modify security configuration such as removeProvider, addProvider, insertProviderAt, setProperty, and removeProperty.

Data tables:

• io.moderne.cryptography.table.SecurityModificationTable: Security class method invocations that modify the Java security configuration including provider management and property settings.

io.moderne.cryptography.FindSecuritySetProperties

• Find Security.setProperty(..) calls for certain properties
• There is a defined set of properties that should not be set using Security.setProperty(..) as they can lead to security vulnerabilities.

Data tables:

• io.moderne.cryptography.table.InsecureSetProperties: An itemization of the properties used in such calls

io.moderne.cryptography.PostQuantumCryptography

• Post quantum cryptography
• This recipe searches for instances in code that may be impacted by post quantum cryptography. Applications may need to support larger key sizes, different algorithms, or use crypto agility to handle the migration. The recipe includes detection of hardcoded values that affect behavior in a post-quantum world, programmatic configuration that may prevent algorithm changes, and general cryptographic usage patterns that should be reviewed.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.
• io.moderne.cryptography.table.InsecureSetProperties: An itemization of the properties used in such calls
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.cryptography.agilesec.BuildCipherInventory

• Build cryptographic cipher inventory
• Builds a cipher inventory for Keyfactor AgileSec by detecting insecure cryptographic algorithm usages across Java (JCA/JCE and BouncyCastle), C# (.NET) and C/C++ (OpenSSL) sources. Every detection is recorded in the shared cipher inventory data table with the algorithm, its function, the library and language, the precise source location, and repository provenance. Phase 1 covers DES, 3DES, RC2, RC4, Blowfish, MD2, MD4, MD5, SHA1 and HMAC-SHA1.

Data tables:

• io.moderne.cryptography.agilesec.table.CipherInventoryTable: Cryptographic algorithm usages detected in source code, including the algorithm, its function, the library and language, the precise source location, and repository provenance.

io.moderne.cryptography.agilesec.FindInsecureCSharpCryptography

• Find insecure C# cryptography
• Detects insecure .NET (System.Security.Cryptography) algorithm usages and records them in a cipher inventory data table.

Data tables:

• io.moderne.cryptography.agilesec.table.CipherInventoryTable: Cryptographic algorithm usages detected in source code, including the algorithm, its function, the library and language, the precise source location, and repository provenance.

io.moderne.cryptography.agilesec.FindInsecureJavaCryptography

• Find insecure Java cryptography
• Detects insecure JCA/JCE and BouncyCastle cryptographic algorithm usages and records them in a cipher inventory data table.

Data tables:

• io.moderne.cryptography.agilesec.table.CipherInventoryTable: Cryptographic algorithm usages detected in source code, including the algorithm, its function, the library and language, the precise source location, and repository provenance.

io.moderne.cryptography.agilesec.FindInsecureNativeCryptography

• Find insecure C/C++ cryptography
• Detects insecure OpenSSL EVP_* algorithm usages in C/C++ source (scanned as plain text) and records them in a cipher inventory data table.

Data tables:

• io.moderne.cryptography.agilesec.table.CipherInventoryTable: Cryptographic algorithm usages detected in source code, including the algorithm, its function, the library and language, the precise source location, and repository provenance.

io.moderne.cryptography.pqc.AddHybridTlsNamedGroup

• Offer a hybrid ML-KEM key exchange group first
• Prepends an ML-KEM hybrid key-exchange group to explicitly configured named-group lists, so that a connection whose groups are pinned can still negotiate post-quantum key exchange. Covers SSLParameters.setNamedGroups and BCSSLParameters.setNamedGroups with a literal array or a same-class private array constant, and System.setProperty("jdk.tls.namedGroups", ...) with a literal value. The group goes first because first means most preferred, which is where JDK 27 puts it by default and where BouncyCastle 1.81 does not — BCJSSE enables the hybrid last, so an explicit hybrid-first list still changes the key share that is offered. Sites that already name any ML-KEM group are left alone silently and produce no row: setNamedGroups throws on a duplicate element, so re-running this recipe has to be a no-op rather than a reordering. Code that configures no named groups at all is deliberately not touched — on JDK 27 that absence is the good state, and inserting a literal list would freeze today's defaults forever. -D flags in shell scripts, Dockerfiles and orchestration manifests are outside a source scan and need a manual audit.

Data tables:

• io.moderne.cryptography.pqc.table.HybridKexEnforcementTable: Named-group configuration rewritten to offer an ML-KEM hybrid group first, and sites flagged as needing manual review because the value is not statically resolvable or the transformation would need a BouncyCastle upgrade to compile. -D flags outside the scanned repository are invisible, so an unchanged repository is not evidence of a hybrid-ready runtime.

io.moderne.cryptography.pqc.AddHybridTlsNamedGroupToProperties

• Offer a hybrid ML-KEM key exchange group first in properties files
• Prepends an ML-KEM hybrid key-exchange group to a jdk.tls.namedGroups value in a .properties file, under either the bare key or Gradle's systemProp. prefix. The group goes first because first means most preferred. An entry that already names any ML-KEM group is left alone silently and produces no row: the JSSE API throws on a duplicate group, so re-running this recipe has to be a no-op. A repository with no such entry is deliberately not given one — on JDK 27 the absence of a pin is the good state.

Data tables:

• io.moderne.cryptography.pqc.table.HybridKexEnforcementTable: Named-group configuration rewritten to offer an ML-KEM hybrid group first, and sites flagged as needing manual review because the value is not statically resolvable or the transformation would need a BouncyCastle upgrade to compile. -D flags outside the scanned repository are invisible, so an unchanged repository is not evidence of a hybrid-ready runtime.

io.moderne.cryptography.pqc.BuildPqcReadinessInventory

• Build post-quantum TLS readiness inventory
• The single discovery entry point for post-quantum TLS readiness. Answers the three questions that decide whether a connection can negotiate a hybrid ML-KEM key exchange: does the module run on a runtime that offers one (JDK 27, or BouncyCastle 1.81 and later), can it still negotiate TLS 1.3 at all, and does it pin its key-exchange groups to classical curves. Changes nothing; every finding lands in one of four data tables.

Data tables:

• io.moderne.cryptography.pqc.table.PqcReadinessTable: Per-module post-quantum TLS readiness derived from the resolved Maven and Gradle dependency models and the JavaVersion markers of the module's Java sources. Modules built by tools OpenRewrite does not parse (Bazel, Ant) and BouncyCastle shaded into fat jars are invisible here, so an absent row is not evidence of health.
• io.moderne.cryptography.pqc.table.TlsConfigurationInventoryTable: TLS protocol version and cipher suite configuration detected in Java sources and in Spring Boot .properties/.yaml files, classified by whether TLS 1.3 — and therefore JEP 527 / BouncyCastle 1.81 hybrid key exchange — remains reachable. Non-JSSE TLS stacks (Netty, OkHttp, Tomcat and Jetty server configuration, -D flags in build files and launch scripts) are out of scope, so an absent row is not evidence that a module has no legacy TLS floor.
• io.moderne.cryptography.pqc.table.TlsNamedGroupsInventoryTable: TLS key-exchange group configuration detected in Java sources, configuration files and checked-in JVM-options values, classified by whether an ML-KEM hybrid group is offered. -D flags in shell scripts, Dockerfiles and orchestration manifests outside the scanned repository are invisible, so an absent row is not evidence that no group pin exists.
• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.cryptography.pqc.BuildTlsConfigurationInventory

• Build TLS protocol configuration inventory
• Inventories every place a codebase decides which TLS protocol versions and cipher suites may be negotiated — Java sources and Spring Boot .properties/.yaml files — and classifies each by whether TLS 1.3, the only version JEP 527 hybrid key exchange exists for, remains reachable. A pinned cipher list with no RFC 8446 suite blocks TLS 1.3 even when the protocol floor allows it. Deliberately excludes the taint-tracking discovery recipes that overlap this surface (FindHardcodedProtocolChoice, FindDirectSSLConfigurationEditing, FindSSLContextSetDefault): they answer "is this value hardcoded?", this answers "is TLS 1.3 still reachable?", and running both doubles every finding.

Data tables:

• io.moderne.cryptography.pqc.table.TlsConfigurationInventoryTable: TLS protocol version and cipher suite configuration detected in Java sources and in Spring Boot .properties/.yaml files, classified by whether TLS 1.3 — and therefore JEP 527 / BouncyCastle 1.81 hybrid key exchange — remains reachable. Non-JSSE TLS stacks (Netty, OkHttp, Tomcat and Jetty server configuration, -D flags in build files and launch scripts) are out of scope, so an absent row is not evidence that a module has no legacy TLS floor.

io.moderne.cryptography.pqc.BuildTlsKeyExchangeInventory

• Build TLS key exchange inventory
• Inventories every place a codebase decides which TLS key-exchange groups it offers, and classifies each by whether an ML-KEM hybrid group is among them. Where a repository configures named groups nowhere, each TLS-using file is reported as ready-on-upgrade rather than left silent.

Data tables:

• io.moderne.cryptography.pqc.table.TlsNamedGroupsInventoryTable: TLS key-exchange group configuration detected in Java sources, configuration files and checked-in JVM-options values, classified by whether an ML-KEM hybrid group is offered. -D flags in shell scripts, Dockerfiles and orchestration manifests outside the scanned repository are invisible, so an absent row is not evidence that no group pin exists.

io.moderne.cryptography.pqc.EnableHybridTlsKeyExchange

• Enable hybrid TLS key exchange
• Prepends an ML-KEM hybrid key-exchange group to explicitly configured named-group lists in Java and .properties sources, and reports the sites that cannot be rewritten safely. Code that configures no named groups is deliberately left alone: on JDK 27 and BouncyCastle 1.81 the provider default already offers a hybrid group, so inserting a literal list there would freeze today's defaults forever.

Data tables:

• io.moderne.cryptography.pqc.table.HybridKexEnforcementTable: Named-group configuration rewritten to offer an ML-KEM hybrid group first, and sites flagged as needing manual review because the value is not statically resolvable or the transformation would need a BouncyCastle upgrade to compile. -D flags outside the scanned repository are invisible, so an unchanged repository is not evidence of a hybrid-ready runtime.

io.moderne.cryptography.pqc.EnforceTls13

• Enforce a TLS 1.3 floor
• Rewrites JSSE, BouncyCastle and Spring Boot protocol configuration to a TLS 1.3 floor across Java, .properties and YAML sources, so that JEP 527 hybrid key exchange — which exists for TLS 1.3 only — can negotiate. Surfaces that cannot be rewritten safely are recorded as Report only rows rather than changed.

Data tables:

• io.moderne.cryptography.pqc.table.ProtocolEnforcementTable: Protocol configuration surfaces rewritten to a TLS 1.3 floor, and surfaces flagged as needing manual review because rewriting them would change behaviour in a way a source scan cannot justify. Rows describe declared configuration only: a JVM's java.security file, container -D flags and environment variables are invisible here, so an enforced source does not prove an enforced runtime.

io.moderne.cryptography.pqc.EnforceTls13Java

• Enforce a TLS 1.3 floor in Java sources
• Rewrites JSSE and BouncyCastle protocol configuration to a TLS 1.3 floor, so that JEP 527 hybrid key exchange — which exists for TLS 1.3 only — can negotiate. Covers SSLContext.getInstance algorithm literals, the setEnabledProtocols/setProtocols sinks including BCSSLParameters, same-file protocol array constants whose only readers are those sinks, the jdk.tls.client.protocols, jdk.tls.server.protocols and https.protocols system properties, and getSupportedVersions overrides on BouncyCastle TlsPeer subclasses. Surfaces that cannot be rewritten safely — an array constant shared with non-TLS code, or a Security.setProperty("jdk.tls.disabledAlgorithms", ...) call that replaces rather than extends the JDK default list — are marked and recorded as Report only rows instead of being changed. Protocol values that are not statically resolvable are left alone without a row: finding those is the discovery recipes' job, and reporting them here would duplicate their findings. Test sources are skipped by default, because a protocol test usually enables a legacy version on purpose in order to assert that it is refused. One shape deserves review before the diff is merged: a protocol list that was deliberately widened to work around a handshake failure against a legacy peer looks exactly like an unmaintained legacy floor, and narrowing it will re-break that peer. Every rewrite is recorded in the enforcement data table with its before and after protocols, and retainTls12In scopes the exception once such a site is identified.

Data tables:

• io.moderne.cryptography.pqc.table.ProtocolEnforcementTable: Protocol configuration surfaces rewritten to a TLS 1.3 floor, and surfaces flagged as needing manual review because rewriting them would change behaviour in a way a source scan cannot justify. Rows describe declared configuration only: a JVM's java.security file, container -D flags and environment variables are invisible here, so an enforced source does not prove an enforced runtime.

io.moderne.cryptography.pqc.EnforceTls13Properties

• Enforce a TLS 1.3 floor in properties files
• Rewrites TLS protocol configuration in .properties files to a TLS 1.3 floor, so that JEP 527 hybrid key exchange — which exists for TLS 1.3 only — can negotiate. Covers server.ssl.enabled-protocols, the jdk.tls.client.protocols, jdk.tls.server.protocols and https.protocols keys, server.ssl.protocol under strictAlgorithmName, and any key named in additionalPropertyKeys. Keys are matched with Spring relaxed binding, so enabled-protocols, enabledProtocols and ENABLED_PROTOCOLS all match. Configuration a source scan cannot see — config servers, ConfigMap overlays, environment variables — is out of scope, so an unchanged repository is not evidence of an enforced floor.

Data tables:

• io.moderne.cryptography.pqc.table.ProtocolEnforcementTable: Protocol configuration surfaces rewritten to a TLS 1.3 floor, and surfaces flagged as needing manual review because rewriting them would change behaviour in a way a source scan cannot justify. Rows describe declared configuration only: a JVM's java.security file, container -D flags and environment variables are invisible here, so an enforced source does not prove an enforced runtime.

io.moderne.cryptography.pqc.EnforceTls13Yaml

• Enforce a TLS 1.3 floor in YAML files
• Rewrites TLS protocol configuration in YAML files to a TLS 1.3 floor, so that JEP 527 hybrid key exchange — which exists for TLS 1.3 only — can negotiate. Covers server.ssl.enabled-protocols, the jdk.tls.client.protocols, jdk.tls.server.protocols and https.protocols keys, server.ssl.protocol under strictAlgorithmName, and any key named in additionalPropertyKeys. Values may be a single scalar, a comma-separated scalar, or a sequence in flow or block style; a sequence is rewritten in place, reusing its existing entries so indentation and comments survive. Configuration a source scan cannot see — config servers, ConfigMap overlays, environment variables — is out of scope, so an unchanged repository is not evidence of an enforced floor.

Data tables:

• io.moderne.cryptography.pqc.table.ProtocolEnforcementTable: Protocol configuration surfaces rewritten to a TLS 1.3 floor, and surfaces flagged as needing manual review because rewriting them would change behaviour in a way a source scan cannot justify. Rows describe declared configuration only: a JVM's java.security file, container -D flags and environment variables are invisible here, so an enforced source does not prove an enforced runtime.

io.moderne.cryptography.pqc.FindMissingHybridTlsNamedGroups

• Find TLS key exchange sites that cannot be made hybrid automatically
• Reports the named-group sites a transformation recipe deliberately leaves alone, so that an empty diff is not mistaken for an empty problem. Three kinds: a setNamedGroups call whose argument is a runtime value, which no source rewrite can reach; a getSupportedGroups override on a BouncyCastle AbstractTlsClient subclass naming no ML-KEM group, where generated code referencing NamedGroup.X25519MLKEM768 would only compile against bctls 1.81 or later and so must ride with a dependency upgrade; and optionally SSL parameters applied without any named-groups configuration, whose remediation is a JDK 27 or BouncyCastle 1.81 upgrade rather than an edit.

Data tables:

• io.moderne.cryptography.pqc.table.HybridKexEnforcementTable: Named-group configuration rewritten to offer an ML-KEM hybrid group first, and sites flagged as needing manual review because the value is not statically resolvable or the transformation would need a BouncyCastle upgrade to compile. -D flags outside the scanned repository are invisible, so an unchanged repository is not evidence of a hybrid-ready runtime.

io.moderne.cryptography.pqc.FindTlsNamedGroupsConfiguration

• Find TLS key exchange (named groups) configuration
• Inventories every place a codebase decides which TLS key-exchange groups it offers, and classifies each by whether an ML-KEM hybrid group — the thing JEP 527 and BouncyCastle 1.81 add — is among them. Covers SSLParameters.setNamedGroups and BCSSLParameters.setNamedGroups, the jdk.tls.namedGroups system property set in code or embedded as a -D flag in checked-in YAML and .properties files, getSupportedGroups overrides on BouncyCastle AbstractTlsClient subclasses, BCJSSE provider registration, and jdk.tls.disabledAlgorithms values that disable a hybrid group. When the repository configures named groups nowhere, each TLS-using file gets one A row: that code is post-quantum ready as soon as it runs on JDK 27 or BouncyCastle 1.81, with no source change. -D flags in shell scripts, Dockerfiles and orchestration manifests outside the repository are invisible, so an absent row is not proof that no group pin exists.

Data tables:

• io.moderne.cryptography.pqc.table.TlsNamedGroupsInventoryTable: TLS key-exchange group configuration detected in Java sources, configuration files and checked-in JVM-options values, classified by whether an ML-KEM hybrid group is offered. -D flags in shell scripts, Dockerfiles and orchestration manifests outside the scanned repository are invisible, so an absent row is not evidence that no group pin exists.

io.moderne.cryptography.pqc.FindTlsPropertyConfiguration

• Find TLS protocol configuration in properties and YAML
• Inventories Spring Boot configuration files that set an embedded server's TLS protocol floor or cipher suites — server.ssl.enabled-protocols, server.ssl.protocol and server.ssl.ciphers, plus any key named in additionalPropertyKeys — and classifies each value by whether TLS 1.3, and therefore JEP 527 hybrid key exchange, remains reachable. A pinned server.ssl.ciphers list with no RFC 8446 suite blocks TLS 1.3 even when the protocol floor allows it. Rows land in the same TLS configuration inventory data table as the Java surface. Keys are matched with relaxed binding, so enabled-protocols, enabledProtocols and ENABLED_PROTOCOLS all match; values may be a single token, a comma-separated string, or a YAML sequence in either flow or block style. Configuration a source scan cannot see — config servers, ConfigMap overlays, environment variables — is out of scope, so an absent row is not evidence of a modern floor.

Data tables:

• io.moderne.cryptography.pqc.table.TlsConfigurationInventoryTable: TLS protocol version and cipher suite configuration detected in Java sources and in Spring Boot .properties/.yaml files, classified by whether TLS 1.3 — and therefore JEP 527 / BouncyCastle 1.81 hybrid key exchange — remains reachable. Non-JSSE TLS stacks (Netty, OkHttp, Tomcat and Jetty server configuration, -D flags in build files and launch scripts) are out of scope, so an absent row is not evidence that a module has no legacy TLS floor.

io.moderne.cryptography.pqc.FindTlsProtocolConfiguration

• Find TLS protocol configuration
• Inventories every place a Java source decides which TLS protocol versions and cipher suites may be negotiated, and classifies each by whether TLS 1.3 — the only version JEP 527 hybrid key exchange exists for — remains reachable. Covers SSLContext.getInstance (whose algorithm name is a ceiling, never a floor), the setProtocols/setEnabledProtocols and setCipherSuites/setEnabledCipherSuites sinks, the jdk.tls.client.protocols, jdk.tls.server.protocols, https.protocols, jdk.tls.client.cipherSuites and jdk.tls.server.cipherSuites system properties, BouncyCastle getSupportedVersions and getSupportedCipherSuites overrides, and default-acquisition sites that configure no floor at all. A pinned cipher list with no RFC 8446 suite blocks TLS 1.3 even when the protocol floor allows it. Findings land in the TLS configuration inventory data table. Scope is JSSE and BouncyCastle: Netty, OkHttp, Apache HttpClient and servlet-container configuration are not scanned, and -D flags in build files and launch scripts are invisible, so an absent row is not evidence of a modern floor.

Data tables:

• io.moderne.cryptography.pqc.table.TlsConfigurationInventoryTable: TLS protocol version and cipher suite configuration detected in Java sources and in Spring Boot .properties/.yaml files, classified by whether TLS 1.3 — and therefore JEP 527 / BouncyCastle 1.81 hybrid key exchange — remains reachable. Non-JSSE TLS stacks (Netty, OkHttp, Tomcat and Jetty server configuration, -D flags in build files and launch scripts) are out of scope, so an absent row is not evidence that a module has no legacy TLS floor.

io.moderne.cryptography.pqc.PqcReadinessAudit

• Audit post-quantum TLS readiness of build files
• Reports how far each Maven and Gradle module is from post-quantum TLS by joining its JDK level with the BouncyCastle artifacts it resolves. Modules with no BouncyCastle get a row too, so absence is reported rather than inferred from an empty table.

Data tables:

• io.moderne.cryptography.pqc.table.PqcReadinessTable: Per-module post-quantum TLS readiness derived from the resolved Maven and Gradle dependency models and the JavaVersion markers of the module's Java sources. Modules built by tools OpenRewrite does not parse (Bazel, Ant) and BouncyCastle shaded into fat jars are invisible here, so an absent row is not evidence of health.

io.moderne.cryptography.pqc.PqcReadinessReport

• Post-quantum TLS readiness report
• Classifies every Maven and Gradle module by how far it is from post-quantum TLS, joining the module's JDK level with the BouncyCastle artifacts it resolves, and records one row per module per BouncyCastle artifact in a data table. Modules with no BouncyCastle at all get exactly one row, so absence is reported rather than inferred from silence. Direct org.bouncycastle declarations in modules that have a gap are marked. bcutil and everything reachable only through it is pruned from the graph walk: it is an internal support artifact that declares BouncyCastle with version ranges, which would otherwise make the reported versions drift with every patch release. Only BouncyCastle that appears in a resolved dependency graph is seen: jars vendored into the repository and wired up with Gradle fileTree/flatDir or Maven system scope, and BouncyCastle shaded into a fat jar, carry no coordinates and therefore report as no-bc. Modules whose build tool did not run are reported as build-file-not-resolved rather than being dropped, so that gap is visible instead of silent.

Data tables:

• io.moderne.cryptography.pqc.table.PqcReadinessTable: Per-module post-quantum TLS readiness derived from the resolved Maven and Gradle dependency models and the JavaVersion markers of the module's Java sources. Modules built by tools OpenRewrite does not parse (Bazel, Ant) and BouncyCastle shaded into fat jars are invisible here, so an absent row is not evidence of health.

io.moderne.cryptography.pqc.UpgradeToPqcReadyTls

• Upgrade to post-quantum ready TLS
• The single transformation entry point for post-quantum TLS readiness. Moves a repository off the end-of-life jdk15on BouncyCastle artifacts onto a hybrid-capable bctls, raises the protocol floor to TLS 1.3, and offers an ML-KEM hybrid key-exchange group first wherever groups are pinned. Run BuildPqcReadinessInventory first: this recipe cannot reach configuration held outside the repository, and the sites it deliberately skips are visible only in its data tables. It also cannot upgrade the runtime, which is the other half of the job — JEP 527 hybrid key exchange exists on JDK 27 and later only.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• io.moderne.cryptography.pqc.table.ProtocolEnforcementTable: Protocol configuration surfaces rewritten to a TLS 1.3 floor, and surfaces flagged as needing manual review because rewriting them would change behaviour in a way a source scan cannot justify. Rows describe declared configuration only: a JVM's java.security file, container -D flags and environment variables are invisible here, so an enforced source does not prove an enforced runtime.
• io.moderne.cryptography.pqc.table.HybridKexEnforcementTable: Named-group configuration rewritten to offer an ML-KEM hybrid group first, and sites flagged as needing manual review because the value is not statically resolvable or the transformation would need a BouncyCastle upgrade to compile. -D flags outside the scanned repository are invisible, so an unchanged repository is not evidence of a hybrid-ready runtime.

rewrite-cve-2026-22732

io.moderne.recipe.cve202622732.FindHttpResponseContentLengthHeader

• Find Content-Length header writes on HttpServletResponse (CVE-2026-22732)
• Detects HttpServletResponse.setHeader, setIntHeader, or addIntHeader calls whose first argument resolves (directly or via local variable) to the literal Content-Length (case-insensitive). These three overloads are NOT overridden by Spring Security's OnCommittedResponseWrapper, so onResponseCommitted() never fires and the lazy-added security headers (X-Frame-Options, X-Content-Type-Options, Cache-Control, etc.) are silently dropped — CVE-2026-22732. addHeader is intentionally excluded: the wrapper special-cases it. Also covers WebFlux HttpHeaders.set / add for Content-Length. In addition to marking Java sinks, attaches a {@code SearchResult} marker to every source file in the affected project so this recipe can be used as a declarative precondition for build-level recipes.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

io.moderne.recipe.cve202622732.FindHttpResponseContentLengthOrFlushBuffer

• Find unconditional WebFlux response commit calls (CVE-2026-22732)
• Detects WebFlux calls that commit a ServerHttpResponse outside the lazy header-writing path: writeWith(..), writeAndFlushWith(..), setComplete(), and HttpHeaders.setContentLength(long). Under CVE-2026-22732 these patterns cause Spring Security's lazy-added security headers to be dropped. The sibling recipe FindHttpResponseContentLengthHeader covers the servlet setHeader / setIntHeader / addIntHeader case. In addition to marking Java sinks, attaches a {@code SearchResult} marker to every source file in the affected project so this recipe can be used as a declarative precondition for build-level recipes.

Data tables:

• io.moderne.recipe.cve202622732.table.HttpResponseDirectCommitTable: Rows for ServerHttpResponse / HttpHeaders calls that commit a WebFlux response outside the lazy header-writing path (writeWith, writeAndFlushWith, setComplete, HttpHeaders.setContentLength).

io.moderne.recipe.cve202622732.FindSpringSecurityHeaderSuppression

• Find CVE-2026-22732 (Spring Security header suppression)
• Detects code susceptible to CVE-2026-22732, where setting Content-Length via HttpServletResponse.setHeader / setIntHeader / addIntHeader (or the WebFlux equivalents) bypasses Spring Security's OnCommittedResponseWrapper, letting the container commit the response before the lazy header-writing filter runs and silently dropping security headers (X-Frame-Options, X-Content-Type-Options, Cache-Control, etc.). Also emits one data-table row per project recording the resolved Spring Security version.

Data tables:

• io.moderne.recipe.cve202622732.table.SpringSecurityVersionByProject: One row per project with a detected Spring Security dependency. Customers join this with the taint-flow / direct-commit findings to see the Spring Security version in effect for each hit.
• io.moderne.recipe.cve202622732.table.HttpResponseDirectCommitTable: Rows for ServerHttpResponse / HttpHeaders calls that commit a WebFlux response outside the lazy header-writing path (writeWith, writeAndFlushWith, setComplete, HttpHeaders.setContentLength).
• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

rewrite-devcenter

io.moderne.devcenter.AngularVersionUpgrade

• Move to a later Angular version
• Determine the current state of a repository relative to a desired Angular version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.ApacheDevCenter

• DevCenter for Apache
• A DevCenter that tracks the latest Apache Maven parent POM versions and applies best practices.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.ApacheMavenBestPractices

• Apache Maven best practices
• A collection of recipes that apply best practices to Maven POMs. Some of these recipes affect build stability, so they are reported as security issues in the DevCenter card.

Data tables:

• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.ApacheMavenDevCenter

• DevCenter for Apache Maven
• A DevCenter that tracks the latest Apache Maven parent POM versions and applies best practices. This DevCenter includes recipes to upgrade the parent POMs of Apache Maven, as well as a collection of best practices for Maven POMs.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.BucketedMetricCard

• DevCenter card from a data table column
• Read rows from a previously emitted data table, aggregate a numeric column across all rows for this repository, and bucket the result into ordinal DevCenter measures.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.BuildToolCard

• Build tool
• Track build tool versions across repositories.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.BuildToolStarter

• DevCenter for Gradle and Maven
• Track and automate upgrades for Gradle, Maven, and Java versions.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.CSharpVersionUpgrade

• Move to a later .NET version
• Determine the current state of a repository relative to a desired .NET version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.ClassCohesionDevCenter

• Class cohesion DevCenter
• A DevCenter that finds class quality metrics for repositories and buckets the average LCOM4 (Lack of Cohesion of Methods, version 4) into HIGH / MEDIUM / LOW cohesion categories.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.
• io.moderne.prethink.table.TestGaps: Public non-trivial methods that have no test coverage, ranked by risk score.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.DependencyVulnerabilityCheck

• Vulnerabilities status
• Determine the current state of a repository relative to its vulnerabilities.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.DevCenterAngularStarter

• DevCenter for Angular
• A default DevCenter configuration for Angular repositories. Track Angular version adoption across your organization.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterCSharpStarter

• DevCenter for C#
• A default DevCenter configuration for C# repositories. Track .NET version adoption across your organization.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterGoStarter

• DevCenter for Go
• A default DevCenter configuration for Go repositories. Track Go version adoption across your organization.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterKotlin

• DevCenter Kotlin
• This is a DevCenter helping you to track general Kotlin Modernisations.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterNodeStarter

• DevCenter for Node.js
• A default DevCenter configuration for Node.js repositories. Track Node.js version adoption across your organization.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterPythonStarter

• DevCenter for Python
• A default DevCenter configuration for Python repositories. Track Python version adoption across your organization.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.DevCenterStarter

• DevCenter
• This is a default DevCenter configuration that can be used as a starting point for your own DevCenter configuration. It includes a combination of upgrades, migrations, and security fixes. You can customize this configuration to suit your needs. For more information on how to customize your DevCenter configuration, see the DevCenter documentation.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.
• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.FindActiveCommitters

• Find active committers on repositories
• List the committers on a repository whose most recent commit falls within the last 90 days, for the DevCenter contributing developers statistic.

Data tables:

• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

io.moderne.devcenter.FindOrganizationStatistics

• Find organization statistics
• Counts lines of code per repository for organization-level statistics.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.

io.moderne.devcenter.GoVersionUpgrade

• Move to a later Go version
• Determine the current state of a repository relative to a desired Go version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.GroovyVersionUpgrade

• Move to a later Groovy version
• Determine the current state of a repository relative to a desired Groovy version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.JUnitJupiterUpgrade

• Move to JUnit 6
• Move to JUnit Jupiter.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.JavaVersionUpgrade

• Move to a later Java version
• Determine the current state of a repository relative to a desired Java version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.KotlinVersionUpgrade

• Move to a later Kotlin version
• Determine the current state of a repository relative to a desired Kotlin version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.LibraryUpgrade

• Library upgrade
• Determine the current state of a repository relative to a desired library upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.NodeVersionUpgrade

• Move to a later Node.js version
• Determine the current state of a repository relative to a desired Node.js version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.ParentPomUpgrade

• Parent POM upgrade
• Determine the current state of a repository relative to a desired parent POM upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.PythonVersionUpgrade

• Move to a later Python version
• Determine the current state of a repository relative to a desired Python version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.QuarkusDevCenter

• DevCenter for Quarkus
• A DevCenter that tracks the latest Quarkus framework versions and applies best practices. This DevCenter includes recipes to upgrade Quarkus versions, migrate from deprecated APIs, and ensure compatibility with the latest Java versions and testing frameworks.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.ReportAsSecurityIssues

• Report as security issues
• Look for results produced by recipes in the same recipe list that this recipe is part of, and report them as security issues in DevCenter.

Data tables:

• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.ScalaVersionUpgrade

• Move to a later Scala version
• Determine the current state of a repository relative to a desired Scala version upgrade.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.devcenter.SecurityStarter

• OWASP top ten
• This recipe is a starter card to reveal common OWASP Top 10 issues in your source code. You can customize this configuration to suit your needs. For more information on how to customize your DevCenter configuration, see the DevCenter documentation.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• io.moderne.devcenter.table.SecurityIssues: Security issues in the repository.

io.moderne.devcenter.UpgradeQuarkus3_x

• Upgrade to Quarkus 3.26
• Upgrades Quarkus dependencies to version 3.26.x, including core, extensions, and tooling.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.devcenter.VulnerabilitiesDevCenter

• DevCenter for Vulnerability Management
• Recipes to analyze and manage dependency vulnerabilities using Moderne DevCenter.

Data tables:

• io.moderne.devcenter.table.OrganizationStatistics: Per-repository statistics aggregated at the organization level.
• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.
• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

rewrite-dropwizard

io.moderne.java.dropwizard.MigrateToDropwizard5

• Migrate to Dropwizard 5.0.x from 4.x
• Apply changes required to upgrade a Dropwizard 4.x application to 5.0.x. This includes upgrading dependencies, removing deprecated configuration options, and migrating Jetty handler implementations. Includes required migrations to Java 17, Jakarta EE 10, JUnit 5, Jackson 2.x, and Hibernate 6.6. See the upgrade guide.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.dropwizard.boot.MigrateDropwizardToSpringBoot3

• Migrate Dropwizard to Spring Boot 3
• Migrate a Dropwizard application to Spring Boot 3. First applies the Dropwizard to Spring Boot 2.7 migration, then adds managed lifecycle and health check migrations on top.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-hibernate

io.moderne.hibernate.search.FindJPQLDefinitions

• Find JPQL definitions
• Find Java Persistence Query Language definitions in the codebase.

Data tables:

• io.moderne.hibernate.search.JPQLQueries: Shows matching JPQL queries.

rewrite-java-application-server

io.moderne.java.server.jboss.PlanJBossMigration

• Plan JBoss migration
• Analyzes the repository to plan a JBoss migration, identifying JBoss descriptor files (jboss-web.xml, jboss-deployment-structure.xml) and recording them in a data table.

Data tables:

• io.moderne.java.server.jboss.PlanJBossMigration$JBossProjects: Summary of JBoss descriptor files found in the repository.

io.moderne.java.server.jboss.jetty.devcenter.JBossToJettyMigrationCard

• JBoss to Jetty migration
• Measures the progress of migrating applications from JBoss to Jetty. Analyzes the presence of JBoss descriptor files (jboss-web.xml, jboss-deployment-structure.xml) and Jetty jetty-env.xml configuration files to determine migration state.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

io.moderne.java.server.jboss.tomcat.devcenter.JBossToTomcatMigrationCard

• JBoss to Tomcat migration
• Measures the progress of migrating applications from JBoss to Tomcat. Analyzes the presence of JBoss descriptor files (jboss-web.xml, jboss-deployment-structure.xml) and Tomcat context.xml configuration files to determine migration state.

Data tables:

• io.moderne.devcenter.table.UpgradesAndMigrations: Progress towards organizational objectives on library or language migrations and upgrades.

rewrite-kafka

io.moderne.kafka.MigrateToKafka40

• Migrate to Kafka 4.0
• Migrate applications to the latest Kafka 4.0 release. This includes updating dependencies to 4.0.x, ensuring Java 11+ for clients and Java 17+ for brokers/tools, and handling changes.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.kafka.MigrateToKafka41

• Migrate to Kafka 4.1
• Migrate applications to the latest Kafka 4.1 release. This includes updating dependencies to 4.1.x, migrating deprecated Admin API methods, updating Streams configuration properties, and removing deprecated broker properties.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.kafka.UpgradeJavaForKafkaBroker

• Upgrade Java to 17+ for Kafka broker/tools
• Ensures Java 17 or higher is used when Kafka broker or tools dependencies are present.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-nullability

io.moderne.nullability.AddMonotonicNonNullToUninitializedField

• Add @MonotonicNonNull to an uninitialized field
• Adds the Checker Framework @MonotonicNonNull to a non-primitive, non-final reference field inside a @NullMarked scope that has no nullability annotation, no initializer, no dependency-injection annotation, and is not definitely assigned by the end of construction (or is read before assignment) — the condition for NullAway's "@NonNull field not initialized" error. A field that is also assigned a literal null is genuinely nullable and gets JSpecify @Nullable instead. Java sources only; idempotent; only annotations are added.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.AddNullableToNullAssignedField

• Add @Nullable to a field assigned a nullable value
• Adds a JSpecify @Nullable to a @NonNull reference field that is assigned a provably-nullable value, which would otherwise trigger NullAway's "assigning @Nullable expression to @NonNull field" error inside a @NullMarked scope. A value is provably nullable when it is the null literal, a call to a nullable-returning method, or a reference to a @Nullable variable or field. Only fires where NullAway is active; idempotent, and leaves a field unchanged when it cannot be resolved. Java sources only.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.AddNullableToNullReturningMethod

• Add @Nullable to a method that can return null
• Adds JSpecify @Nullable to a method or lambda whose effective return type is non-null but that returns a provably-nullable value, a NullAway error inside a @NullMarked scope. A regular method has its return type widened to JSpecify @Nullable in the type-use position; when the non-null return contract cannot be widened (an override of a non-null supertype return, or a lambda whose functional-interface return is non-null) the returned expression is wrapped in java.util.Objects.requireNonNull(...) instead, leaving runtime behavior unchanged. Nullability is determined from type attribution, and an unconditional return null is left for a human. The recipe is idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.AddNullnessContractToValidationHelper

• Add a @Contract nullness contract to a validation helper
• Adds an org.jetbrains.annotations.@Contract annotation to a single-@Nullable-parameter helper method whose body provably encodes a nullness contract, so the checker can narrow at every call site without any runtime assertion. Three canonical body shapes are recognized: a boolean-returning method whose body is return arg != null && ...; (the argument's non-nullity is a required conjunct) becomes @Contract("null -> false"); a method that unconditionally throws — or delegates to requireNonNull / checkNotNull — when the argument is null becomes @Contract("null -> fail"); and an identity pass-through that returns the argument unchanged becomes @Contract("null -> null"). Only methods with exactly one parameter, a simple recognizable body, and no existing @Contract are annotated. The edit is annotation-only and behavior-preserving — runtime semantics are unchanged. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.AlignOverrideNullabilityWithSupertype

• Align override nullability with the supertype
• Aligns a method or lambda parameter whose declared nullability is inconsistent with the supertype member it overrides, a contract violation under NullAway. An override that restricts a @Nullable supertype parameter to non-null has JSpecify @Nullable added to that parameter (parameters are contravariant); an override that widens a non-null supertype return to @Nullable has the erroneous @Nullable removed from its return type and its @Nullable returns wrapped in java.util.Objects.requireNonNull(...) (return types are covariant), which leaves runtime behavior unchanged. Conservative: a supertype's annotations are trusted only when the supertype is itself in an annotated scope, a return null and a null-guarded return are never wrapped, and nothing is changed when a participating type cannot be resolved. Idempotent; Java sources only.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.CollapseOptionalPresentGuardToGet

• Route a guarded raw accessor through its present Optional
• Inside the then-branch of an if (xOpt().isPresent()) \{ ... \} guard, rewrites a sibling raw nullable accessor getX() to xOpt().get(), so the checker flows non-null through the Optional instead of needing a requireNonNull. NullAway flags the bare getX() dereference because the accessor is @Nullable, but the enclosing isPresent() guard already proves the corresponding Optional is present; reading through xOpt().get() re-expresses the same value via the guarded, provably-present Optional. The rewrite is gated for correctness over coverage: the guard must be exactly <recv>.isPresent() on a no-argument, side-effect-free Optional accessor; the rewritten getX() must be the matching no-argument raw accessor (same enclosing receiver, and <recv> named getX plus an Optional suffix) that is provably @Nullable here; and the use must be lexically inside the then-block so the guard dominates it. Because the Optional is proven present in the guarded branch, .get() cannot throw where the raw accessor did not, so runtime behavior is unchanged. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.ExtractRepeatedNullableInvocationToLocal

• Extract a repeated @Nullable invocation into a local variable
• When the same side-effect-free @Nullable method invocation (textually identical receiver, name, and no arguments — e.g. source.get()) appears two or more times in one block, hoists it into a single local @Nullable Type x = source.get(); declared just before the first use and replaces every occurrence with x. NullAway cannot refine a @Nullable return across two separate calls — the second could return a different value — so if (source.get() != null) \{ source.get().foo(); \} is rejected; one local gives the checker a single narrowing point. The rewrite is strictly gated: the call must be provably @Nullable (resolved from the nullability model), side-effect free (only a no-argument getter-style call whose receiver is a simple identifier or this, never an argument-bearing or unresolved-type call), all occurrences must be in the same block, and the receiver must not be reassigned anywhere in that block (which could change the value between calls). A pure call evaluated once rather than N times yields the same value, so runtime behavior is unchanged. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.NullSafety

• Make a codebase null-safe
• Make Java code null-safe end to end. Infers and adds JSpecify @Nullable/@MonotonicNonNull from the code's own signals (returns, parameters, fields, override hierarchies, Kotlin call sites, and the JSpecify generic frontier), then detects and repairs the residual nullability violations — dereferences, unboxing, switch, enhanced-for, passing a nullable argument, nullable returns, uninitialized non-null fields, and override consistency — directly from the LST. Behavior-preserving and idempotent; run to a fixpoint over recipe cycles. If the code still uses non-JSpecify annotation flavors, run org.openrewrite.java.jspecify.MigrateToJSpecify first.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.RelaxOptionalOfToOfNullable

• Relax Optional.of to Optional.ofNullable on nullable values
• Rewrites Optional.of(x) to Optional.ofNullable(x) where the argument x is provably @Nullable at the call site. Optional.of(null) throws NullPointerException, while Optional.ofNullable(null) yields Optional.empty(), so the two factories diverge on the null path: this rewrite changes observable runtime behavior (an NPE becomes an empty optional) and therefore marks every call it changes for human review. The call is matched on java.util.Optional of(..); the argument's nullness is resolved from the nullness oracle and the path-sensitive flow engine (no name-based heuristics), so a value already null-checked on the path is not flagged. A non-null literal argument, or one already protected by a non-null assertion (requireNonNull / castToNonNull / …), is left untouched, keeping the recipe idempotent. Gated on the call site being in an annotated scope; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.RemoveProvablyDeadNullGuard

• Remove a provably-dead if (x == null) guard
• Removes an if (x == null) \{ ... \} guard whose then-branch the flow engine proves unreachable because x is already non-null at that point (e.g. after an earlier assertion, guard, or assignment). Such a guard is dead code: the x == null test can never be true, so its then-branch never executes and deleting it — while keeping any else body, the only live path — preserves behavior. To match the aggressiveness Airbnb endorses and no further, the removal fires only when the path-sensitive flow analysis decisively proves x non-null at the guard, and never on a parameter of a public method (the service-edge / untrusted-input validation point NullAway guidance explicitly excludes). The condition must be a bare x == null / null == x on a simple local or parameter; a compound condition, a field, or anything not flow-proven is left untouched. Behavior-preserving (it removes only unreachable code), idempotent, and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.RemoveRedundantNonNullAnnotation

• Remove a redundant @NonNull annotation under @NullMarked
• Removes an explicit @NonNull / @Nonnull annotation that is redundant inside a @NullMarked scope, where non-null is already the default. In JSpecify-normalized code an unannotated declaration in an annotated scope is already non-null, so the annotation merely restates the default; removing it leaves the declared nullability — and therefore runtime behavior — unchanged. Conservative: it acts only on a declaration whose enclosing type is in the fix scope (@NullMarked / AnnotatedPackages), removing the annotation from either the leading (declaration) position or the TYPE_USE position; it never touches @Nullable, @CheckForNull, or @MonotonicNonNull. The annotation import is dropped when this was its last use. Annotation-only and idempotent; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.ReplaceNullableToStringWithStringValueOf

• Replace nullable x.toString() with String.valueOf(x)
• Rewrites x.toString() to String.valueOf(x) when the receiver x is provably nullable at that site. x.toString() dereferences x and throws NullPointerException when x is null, which NullAway flags inside an annotated scope; String.valueOf(x) returns the string "null" instead. This is a behavior change on the null path (NullPointerException becomes the string "null"), so every rewritten call is marked for review — it is not behavior-preserving. Only the no-arg toString() whose receiver is a reference value is rewritten; a primitive receiver, a type or package qualifier, a .class literal, and this/super are never touched, and a receiver already asserted non-null is skipped. The receiver's nullness is resolved by attribution from the nullability model and a path-sensitive flow analysis (a value already null-checked on the path is not flagged). The fix never rewrites a call whose receiver is genuinely non-null at the site. Conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.ReturnEmptyCollectionInsteadOfNull

• Return an empty collection instead of null
• Rewrites a bare return null; to return an empty immutable collection when the enclosing method's declared return type is java.util.List, java.util.Set, java.util.Collection, or java.util.Map (raw or generic): List and Collection become Collections.emptyList(), Set becomes Collections.emptySet(), and Map becomes Collections.emptyMap() (each statically imported). Returning an empty collection rather than null spares every caller a null check, but a caller that distinguishes null from empty observes a different result, so this is a behavior change and every rewritten return is flagged for review. Only the literal return null; statement is rewritten — a return someNullableExpr; is left untouched — and a method whose return is annotated @Nullable is skipped, since there the null is intended. The recipe is gated on @NullMarked scope, idempotent, and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.SafeNullableBooleanCondition

• Make a nullable Boolean condition null-safe with Boolean.TRUE.equals(...)
• Rewrites a provably-nullable boxed Boolean used as a condition that auto-unboxes to boolean — the control expression of an if, while, or do/while, the condition of a for, or the condition of a ternary ?: — to Boolean.TRUE.equals(cond). Inside an annotated scope NullAway flags such an unboxing because it throws NullPointerException when the Boolean is null; the Boolean.TRUE.equals(...) form yields false on null instead. This is a behavior change on the null path (a thrown NullPointerException becomes false), so each rewritten condition is stamped with a behavior-change marker recording exactly that. The fix fires only when the condition's static type is the boxed java.lang.Boolean (a primitive boolean is never touched) and it is provably nullable at the site; nullability comes from type attribution and a path-sensitive flow analysis (a value already null-checked on the path is not rewritten). A condition already wrapped in Boolean.TRUE.equals(...) or requireNonNull(...) is left unchanged (idempotent). The recipe is conservative — a value not proven nullable is never rewritten; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableArgumentInRequireNonNull

• Wrap nullable arguments passed to non-null parameters in requireNonNull
• Wraps in java.util.Objects.requireNonNull(...) (statically imported) each argument that passes a provably-nullable value to a callee parameter that is not declared @Nullable. Inside a @NullMarked scope NullAway treats every unannotated parameter as non-null, so such a call is an error; requireNonNull throws only where the @NonNull callee would already misbehave on null, so runtime behavior is unchanged. Argument and parameter nullness are resolved from the nullness oracle and the flow engine (no name-based heuristics). The fix only fires where the call site is @NullMarked and the callee is itself in an annotated scope, and never asserts non-null on a value that is genuinely nullable at the site (a value read inside its own null-check is left for a human). A value that is explicitly null on some path (a bare null literal or a ternary with a null arm) is not wrapped but flagged for review with an advisory marker, since the parameter likely should be @Nullable. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableDereferenceInRequireNonNull

• Wrap nullable dereferenced values in requireNonNull
• Wraps in java.util.Objects.requireNonNull(...) (statically imported) a provably-nullable value that is being dereferenced — the receiver of a method call (x.foo()), the target of a field access (x.field, including x.length), the base of an array index (x[i]), the qualifier of a method reference (x::foo), the outer instance of a qualified new, or the lock of a synchronized (x). Inside an annotated scope NullAway treats such a dereference as an error because it throws NullPointerException when the value is null; requireNonNull throws exactly when the dereference already would, so runtime behavior is unchanged. The value's nullness is resolved by attribution from the nullability model and a path-sensitive flow analysis (a value already null-checked on the path is not flagged). A .class literal, a type or package qualifier, a primitive, and a throw expression are never touched. The fix never asserts non-null on a value that is genuinely nullable at the site. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableForEachIterableInRequireNonNull

• Wrap a nullable for-each iterable in requireNonNull
• Wraps the iterable of an enhanced-for (for-each) loop in java.util.Objects.requireNonNull(...) (statically imported) when it is a provably-nullable value. Inside an annotated scope NullAway treats the for-each iterable as non-null, so iterating a nullable expression is an error; iterating a null already throws NullPointerException when the loop obtains its iterator, so requireNonNull throws exactly where the loop already would and runtime behavior is unchanged. The iterable's nullness is resolved by attribution from the nullability model and a path-sensitive flow analysis. The fix never asserts non-null on a value that is genuinely nullable at the site. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableSwitchSelectorInRequireNonNull

• Wrap nullable switch selectors in requireNonNull
• Wraps a provably-nullable switch selector in java.util.Objects.requireNonNull(...) (statically imported). Switching on a null selector already throws NullPointerException (the selector is dereferenced before any case matches), so inside an annotated scope NullAway flags a nullable selector as an error; requireNonNull throws only where the switch would already fail, so runtime behavior is unchanged. The selector's nullness is resolved by attribution from the nullability model and a path-sensitive flow analysis. A switch that already has a case null label is never touched. The fix never asserts non-null on a value that is genuinely nullable at the site. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableThrownExpressionInRequireNonNull

• Wrap nullable thrown expressions in requireNonNull
• Wraps a provably-nullable throw operand in java.util.Objects.requireNonNull(...) (statically imported), turning throw ex; into throw requireNonNull(ex);. A throw of a null Throwable itself throws NullPointerException (the JVM dereferences the operand to raise it), so inside an annotated scope NullAway flags a nullable thrown value as an error; requireNonNull throws exactly where the bare throw already would, so runtime behavior is unchanged. The operand's nullness is resolved by attribution from the nullability model and a path-sensitive flow analysis (a value already null-checked on the path is not flagged). The fix never asserts non-null on a value that is genuinely nullable at the site. Idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

io.moderne.nullability.WrapNullableUnboxingInRequireNonNull

• Wrap nullable values that are auto-unboxed in requireNonNull
• Wraps a provably-nullable boxed value (Integer, Long, Boolean, ...) that is used in a primitive context in java.util.Objects.requireNonNull(...) (statically imported). Unboxing such a value is a NullAway error inside an annotated scope, and auto-unboxing a null already throws NullPointerException, so requireNonNull throws exactly where the unboxing already would and runtime behavior is unchanged. The primitive contexts handled are an operand of an arithmetic, relational, or bitwise expression whose other side is a primitive (including ==/!= against a primitive, but not a reference comparison or string concatenation), an argument bound to a primitive callee parameter, an array index, an if/while/do/for/ternary condition, and the return of a primitive-returning method. Nullability is determined from type attribution. The fix only fires where NullAway is active and never asserts non-null on a value that is genuinely nullable at the site. The recipe is idempotent and conservative; only Java sources are modified.

Data tables:

• io.moderne.nullability.table.NullFixes: Each residual null-safety fix applied, tagged with the precedence rung that produced it, so the share bottoming out at a last-resort requireNonNull assertion can be tracked.
• io.moderne.nullability.table.DeclinedNullFixes: Each site the recipe declined to auto-fix because the fix is a design decision (the value is explicitly null on some path, so the slot likely should be @Nullable), for human triage.

rewrite-prethink

io.moderne.prethink.ExtractCodingConventions

• Extract coding conventions
• Analyze the codebase to extract coding conventions including naming patterns, import organization, and documentation patterns.

Data tables:

• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.

io.moderne.prethink.ExtractDependencyUsage

• Extract dependency usage patterns
• Analyze the codebase to extract dependency usage patterns by examining which types from external libraries are actually used in the code.

Data tables:

• org.openrewrite.prethink.table.DependencyUsage: External library dependencies and how they are used in the codebase.

io.moderne.prethink.ExtractErrorPatterns

• Extract error handling patterns
• Analyze the codebase to extract error handling patterns including exception types, handling strategies, and logging frameworks used.

Data tables:

• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.

io.moderne.prethink.ExtractGoDependencies

• Extract Go dependencies and usage
• Scan go.mod and Go source imports to produce a DependencyUsage entry per actually-imported module, including file-count and sample imports.

Data tables:

• org.openrewrite.prethink.table.DependencyUsage: External library dependencies and how they are used in the codebase.

io.moderne.prethink.ExtractNodeDependencies

• Extract Node.js dependencies and usage
• Scan package.json and JavaScript/TypeScript imports to produce a DependencyUsage entry per actually-imported npm package, including the symbols imported from it, the import styles in use, and how many files import it.

Data tables:

• org.openrewrite.prethink.table.DependencyUsage: External library dependencies and how they are used in the codebase.

io.moderne.prethink.ExtractRubyDependencies

• Extract Ruby dependencies
• Read Gemfile, gemspec and Gemfile.lock manifests and emit rows into the shared dependency-list-report table, mirroring the JVM dependency inventory. Records the Bundler group a gem was declared in and whether it comes from a git or path source rather than RubyGems, and joins the resolved versions in Gemfile.lock, including transitive gems, onto the gems the Gemfile and gemspec declare.

Data tables:

• org.openrewrite.java.dependencies.table.DependencyListReport: Lists all Gradle and Maven dependencies

io.moderne.prethink.FindGoCodingConventions

• Find Go coding conventions
• Detect Go naming patterns (package names, exported vs unexported, interface -er suffix, error variable prefix, test prefix).

Data tables:

• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.

io.moderne.prethink.FindGoErrorPatterns

• Find Go error handling patterns
• Detect Go error-handling idioms: error returns, fmt.Errorf %w wrapping, errors.Is/As, panic/recover, and sentinel error variables.

Data tables:

• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.

io.moderne.prethink.FindNodeCodingConventions

• Find JavaScript and TypeScript coding conventions
• Detect JavaScript/TypeScript conventions the Java convention extractor cannot see: import styles (default, named, namespace, type-only, side-effect, path-alias), React hook and component naming, the Props suffix for prop types, UPPER_SNAKE_CASE constants, and JSDoc comments.

Data tables:

• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.

io.moderne.prethink.FindRubyCodingConventions

• Find Ruby coding conventions
• Detect Ruby conventions the Java convention extractor cannot see: snake_case method names, the ? and ! method suffixes, the frozen_string_literal magic comment, require versus require_relative, module namespacing depth, and whether visibility is declared as a section or per method.

Data tables:

• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.

io.moderne.prethink.FindRubyErrorPatterns

• Find Ruby error handling patterns
• Detect Ruby error-handling idioms: bare, bound and typed rescue clauses, the rescue modifier, ensure, retry, raise with a class versus a string, custom error classes, and whether rescues log through Rails.logger or a bare logger.

Data tables:

• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.

io.moderne.prethink.PythonDependencyReport

• Python dependency report
• Read the dependency graph attached to Python manifests (pyproject.toml, Pipfile, requirements.txt, setup.cfg) by the parser and emit rows into the shared dependency-list-report table, mirroring the JVM dependency inventory. Includes declared (direct) dependencies and, when a lock file resolved them, transitive dependencies with concrete versions.

Data tables:

• org.openrewrite.java.dependencies.table.DependencyListReport: Lists all Gradle and Maven dependencies

io.moderne.prethink.UpdatePrethinkContextNoAiStarter

• Update Prethink context (no AI)
• Deprecated alias for io.moderne.prethink.UpdatePrethinkContextStarter, retained for backward compatibility with references to the former recipe name. Prethink no longer has an AI-based variant, so the "(no AI)" distinction is unnecessary. Use io.moderne.prethink.UpdatePrethinkContextStarter instead.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.
• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.
• io.moderne.prethink.table.EndpointSchemas: Per-endpoint request body and response body bindings, one row per (endpoint, status code) pair. Supports OpenAPI 3.0.3 generation by giving the LLM a full mapping from handler to body DTO FQNs.
• io.moderne.prethink.table.EndpointParameters: Per-parameter detail for REST endpoint handlers - path, query, header, form. Join to service-endpoints.csv via endpointId.
• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.
• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.
• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.
• org.openrewrite.prethink.table.ServerConfiguration: Server configuration properties extracted from application.properties/yml.
• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.
• io.moderne.prethink.table.DtoFieldSchemas: Per-field schema detail for request/response DTOs: wire name, type, required flag, OpenAPI format, validation constraints, and any @Schema(example=) example values.
• io.moderne.prethink.table.FieldExamples: Raw (fixturePath, jsonPath, value, valueType) rows mined from JSON fixture files. Supply realistic example payloads for contract test generation. LLM correlates jsonPath to DTO fields at spec/contract generation time.
• org.openrewrite.prethink.table.DeploymentArtifacts: Deployment configuration files (Dockerfile, Kubernetes manifests, docker-compose).
• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.
• org.openrewrite.prethink.table.ServiceComponents: Service layer components (@Service, @Component, @Named) in the application.
• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.
• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.
• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.
• io.moderne.prethink.table.ExceptionHandlers: Spring @ExceptionHandler/@ControllerAdvice and JAX-RS ExceptionMapper bindings: exception type -> HTTP status -> response body FQN. Used to complete the 'responses' section of an OpenAPI spec with non-2xx branches.
• io.moderne.prethink.table.EndpointSecurity: Per-endpoint security requirements: roles, scopes, and the raw SpEL/permission expressions from @PreAuthorize/@Secured/@RolesAllowed at method or class level.
• org.openrewrite.prethink.table.DependencyUsage: External library dependencies and how they are used in the codebase.
• org.openrewrite.prethink.table.CalmRelationships: Method call graph for discovering relationships between architectural entities. Records all method calls within the repository with entity markers for graph traversal.
• io.moderne.prethink.table.MethodQualityMetrics: Per-method code quality metrics including cyclomatic complexity, cognitive complexity, nesting depth, Halstead measures, and ABC metric.
• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.
• io.moderne.prethink.table.PackageQualityMetrics: Per-package architectural metrics including afferent/efferent coupling, instability, abstractness, distance from main sequence, and dependency cycle membership.
• io.moderne.prethink.table.CodeSmells: Detected code smells including God Class, Feature Envy, and Data Class with severity ratings and the metric evidence that triggered detection.
• io.moderne.prethink.table.SqlUsage: Physical tables and columns each SQL statement touches, attributed to the class and method that issues it.
• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.
• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.
• io.moderne.prethink.table.TestGaps: Public non-trivial methods that have no test coverage, ranked by risk score.
• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.
• org.openrewrite.java.dependencies.table.DependencyListReport: Lists all Gradle and Maven dependencies
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.
• org.openrewrite.prethink.table.ContextRegistry: Registry of available context files for coding agents.

io.moderne.prethink.UpdatePrethinkContextStarter

• Update Prethink context
• Generate Moderne Prethink context files with architectural discovery, test coverage mapping, dependency inventory, and FINOS CALM architecture diagrams.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.
• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.
• io.moderne.prethink.table.EndpointSchemas: Per-endpoint request body and response body bindings, one row per (endpoint, status code) pair. Supports OpenAPI 3.0.3 generation by giving the LLM a full mapping from handler to body DTO FQNs.
• io.moderne.prethink.table.EndpointParameters: Per-parameter detail for REST endpoint handlers - path, query, header, form. Join to service-endpoints.csv via endpointId.
• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.
• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.
• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.
• org.openrewrite.prethink.table.ServerConfiguration: Server configuration properties extracted from application.properties/yml.
• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.
• io.moderne.prethink.table.DtoFieldSchemas: Per-field schema detail for request/response DTOs: wire name, type, required flag, OpenAPI format, validation constraints, and any @Schema(example=) example values.
• io.moderne.prethink.table.FieldExamples: Raw (fixturePath, jsonPath, value, valueType) rows mined from JSON fixture files. Supply realistic example payloads for contract test generation. LLM correlates jsonPath to DTO fields at spec/contract generation time.
• org.openrewrite.prethink.table.DeploymentArtifacts: Deployment configuration files (Dockerfile, Kubernetes manifests, docker-compose).
• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.
• org.openrewrite.prethink.table.ServiceComponents: Service layer components (@Service, @Component, @Named) in the application.
• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.
• org.openrewrite.prethink.table.CodingConventions: Coding conventions and patterns detected in the codebase.
• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.
• io.moderne.prethink.table.ExceptionHandlers: Spring @ExceptionHandler/@ControllerAdvice and JAX-RS ExceptionMapper bindings: exception type -> HTTP status -> response body FQN. Used to complete the 'responses' section of an OpenAPI spec with non-2xx branches.
• io.moderne.prethink.table.EndpointSecurity: Per-endpoint security requirements: roles, scopes, and the raw SpEL/permission expressions from @PreAuthorize/@Secured/@RolesAllowed at method or class level.
• org.openrewrite.prethink.table.DependencyUsage: External library dependencies and how they are used in the codebase.
• org.openrewrite.prethink.table.CalmRelationships: Method call graph for discovering relationships between architectural entities. Records all method calls within the repository with entity markers for graph traversal.
• io.moderne.prethink.table.MethodQualityMetrics: Per-method code quality metrics including cyclomatic complexity, cognitive complexity, nesting depth, Halstead measures, and ABC metric.
• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.
• io.moderne.prethink.table.PackageQualityMetrics: Per-package architectural metrics including afferent/efferent coupling, instability, abstractness, distance from main sequence, and dependency cycle membership.
• io.moderne.prethink.table.CodeSmells: Detected code smells including God Class, Feature Envy, and Data Class with severity ratings and the metric evidence that triggered detection.
• io.moderne.prethink.table.SqlUsage: Physical tables and columns each SQL statement touches, attributed to the class and method that issues it.
• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.
• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.
• io.moderne.prethink.table.TestGaps: Public non-trivial methods that have no test coverage, ranked by risk score.
• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.
• org.openrewrite.java.dependencies.table.DependencyListReport: Lists all Gradle and Maven dependencies
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.
• org.openrewrite.prethink.table.ContextRegistry: Registry of available context files for coding agents.

io.moderne.prethink.calm.FindActiveRecordModels

• Find ActiveRecord models
• Identify ActiveRecord model classes in Ruby on Rails applications. Detects classes whose superclass chain reaches ApplicationRecord or ActiveRecord::Base, taking the table name from an explicit self.table_name, from the single-table inheritance parent that owns the table, or by pluralizing the class name, and skipping abstract classes. Also detects connects_to and establish_connection connections and Mongoid documents, and joins the database type from the adapter: of config/database.yml.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindAspNetCoreEndpoints

• Find ASP.NET Core endpoints
• Identify HTTP endpoints declared via ASP.NET Core controllers ([ApiController], [Route], [HttpGet/Post/...]) and Minimal APIs (app.MapGet/MapPost/MapPut/MapDelete/MapPatch).

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindAspNetFrameworkEndpoints

• Find ASP.NET Framework endpoints (Web API 2 and MVC 5)
• Identify HTTP endpoints declared in classic .NET Framework web applications: ASP.NET Web API 2 controllers (System.Web.Http.ApiController) and ASP.NET MVC 5 controllers (System.Web.Mvc.Controller), covering both attribute routing ([Route], [RoutePrefix], [HttpGet/Post/...], [AcceptVerbs]) and the default convention-based routes.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindCalmRelationships

• Find CALM relationships
• Discover method call relationships within the repository for building interaction diagrams. Captures all method-to-method calls between in-repo classes. Entity IDs are resolved by GenerateCalmArchitecture when building CALM relationships.

Data tables:

• org.openrewrite.prethink.table.CalmRelationships: Method call graph for discovering relationships between architectural entities. Records all method calls within the repository with entity markers for graph traversal.

io.moderne.prethink.calm.FindDataAssets

• Find data assets
• Identify data assets including JPA entities, MongoDB documents, Java records, and DTOs in the application.

Data tables:

• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.

io.moderne.prethink.calm.FindDatabaseConnections

• Find database connections
• Identify database connections and data access patterns in the application. Detects JPA entities, Spring Data repositories, JDBC templates, MyBatis mappers, and Quarkus Panache.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindDeploymentArtifacts

• Find deployment artifacts
• Identify deployment artifacts including Dockerfiles, docker-compose files, and Kubernetes manifests.

Data tables:

• org.openrewrite.prethink.table.DeploymentArtifacts: Deployment configuration files (Dockerfile, Kubernetes manifests, docker-compose).

io.moderne.prethink.calm.FindDjangoEndpoints

• Find Django endpoints
• Identify REST/HTTP endpoints in Django and Django REST Framework applications. Detects class-based views, function-based views with @api_view, and regular Django views with @require_http_methods decorators.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindDotnetDataAssets

• Find .NET data assets
• Detect C# DTOs, records, and entity types based on property/method ratio, [DataContract] / [Table] attributes, and record keyword.

Data tables:

• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.

io.moderne.prethink.calm.FindDotnetDtoFieldSchemas

• Find .NET DTO field schemas
• Per-property schema rows for C# DTOs: serialized name (JsonPropertyName/JsonProperty), OpenAPI format, required flag (DataAnnotations.RequiredAttribute / non-nullable value types), and a validations JSON map.

Data tables:

• io.moderne.prethink.table.DtoFieldSchemas: Per-field schema detail for request/response DTOs: wire name, type, required flag, OpenAPI format, validation constraints, and any @Schema(example=) example values.

io.moderne.prethink.calm.FindDotnetEndpointContracts

• Find .NET endpoint contracts
• Extract request body, response body (unwrapping ActionResult<T>/Task<T>), and per-parameter binding source ([FromBody/Query/Route/Header/Form]) for ASP.NET Core controller endpoints.

Data tables:

• io.moderne.prethink.table.EndpointSchemas: Per-endpoint request body and response body bindings, one row per (endpoint, status code) pair. Supports OpenAPI 3.0.3 generation by giving the LLM a full mapping from handler to body DTO FQNs.
• io.moderne.prethink.table.EndpointParameters: Per-parameter detail for REST endpoint handlers - path, query, header, form. Join to service-endpoints.csv via endpointId.

io.moderne.prethink.calm.FindDotnetEndpointSecurity

• Find .NET endpoint security
• Per-endpoint security requirements derived from ASP.NET Core [Authorize] (Policy/Roles/AuthenticationSchemes) and [AllowAnonymous].

Data tables:

• io.moderne.prethink.table.EndpointSecurity: Per-endpoint security requirements: roles, scopes, and the raw SpEL/permission expressions from @PreAuthorize/@Secured/@RolesAllowed at method or class level.

io.moderne.prethink.calm.FindDotnetExceptionHandlers

• Find .NET exception handlers
• Detect IExceptionFilter / IAsyncExceptionFilter / IExceptionHandler implementations and ExceptionFilterAttribute-derived classes in ASP.NET Core projects.

Data tables:

• io.moderne.prethink.table.ExceptionHandlers: Spring @ExceptionHandler/@ControllerAdvice and JAX-RS ExceptionMapper bindings: exception type -> HTTP status -> response body FQN. Used to complete the 'responses' section of an OpenAPI spec with non-2xx branches.

io.moderne.prethink.calm.FindDotnetGraphQLEndpoints

• Find .NET GraphQL endpoints
• Detect HotChocolate query/mutation/subscription types and GraphQL.NET schema types in .NET projects.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindDotnetGrpcServices

• Find .NET gRPC services
• Detect gRPC service implementations (classes deriving from generated *Base types under Grpc.Core / Grpc.AspNetCore) and ASP.NET Core gRPC endpoint registrations via MapGrpcService<T>().

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindDotnetHttpClients

• Find .NET HTTP clients
• Detect outbound HTTP client usage via HttpClient, IHttpClientFactory.CreateClient, Refit interfaces, RestSharp, and Flurl.

Data tables:

• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.

io.moderne.prethink.calm.FindDotnetMessagingConnections

• Find .NET messaging connections
• Detect MassTransit IConsumer<T>, NServiceBus IHandleMessages<T>, MediatR IRequestHandler/INotificationHandler, Confluent.Kafka producers/consumers, Azure Service Bus, and RabbitMQ.Client usage.

Data tables:

• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.

io.moderne.prethink.calm.FindDotnetProjectMetadata

• Find .NET project metadata
• Extract project metadata (SDK, target framework(s), package list) from MSBuild project files. Reads the MSBuildProject marker which captures values resolved across the project file, Directory.Build.props, Directory.Packages.props, global.json and nuget.config.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindDotnetScheduledTasks

• Find .NET scheduled tasks
• Detect Hangfire RecurringJob.AddOrUpdate, Quartz.IJob implementations, BackgroundService/IHostedService classes, and Azure Functions TimerTrigger methods.

Data tables:

• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.

io.moderne.prethink.calm.FindDotnetSecurityConfiguration

• Find .NET security configuration
• Detect ASP.NET Core authentication (JwtBearer/OpenIdConnect/Cookie), authorization, CORS, HSTS, and HTTPS redirection middleware registrations.

Data tables:

• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.

io.moderne.prethink.calm.FindDotnetServerConfiguration

• Find .NET server configuration
• Read appsettings*.json and launchSettings.json for Kestrel Urls/ApplicationUrl entries and emit ServerConfiguration rows (port, sslEnabled, contextPath, protocol).

Data tables:

• org.openrewrite.prethink.table.ServerConfiguration: Server configuration properties extracted from application.properties/yml.

io.moderne.prethink.calm.FindDotnetServiceComponents

• Find .NET service components
• Detect IServiceCollection.AddSingleton/AddScoped/AddTransient/AddHttpClient registrations and emit one row per registered service.

Data tables:

• org.openrewrite.prethink.table.ServiceComponents: Service layer components (@Service, @Component, @Named) in the application.

io.moderne.prethink.calm.FindDotnetTestCoverage

• Find .NET test coverage
• Identify xUnit ([Fact]/[Theory]), NUnit ([Test]/[TestCase]) and MSTest ([TestMethod]/[DataTestMethod]) test methods in C# source and record them in the test mapping table for downstream coverage linking.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.calm.FindDtoFieldSchemas

• Find DTO field schemas
• Emit per-field rows for request/response DTO classes: wire name, type, required flag, OpenAPI format, validation constraints, and @Schema(example = ...) values. Supports OpenAPI 3.0.3 generation by providing the full field schema for each DTO an endpoint references.

Data tables:

• io.moderne.prethink.table.DtoFieldSchemas: Per-field schema detail for request/response DTOs: wire name, type, required flag, OpenAPI format, validation constraints, and any @Schema(example=) example values.

io.moderne.prethink.calm.FindEndpointContracts

• Find endpoint contracts
• Extract per-endpoint request body, response body (per status code), and parameter details from Spring/JAX-RS/Micronaut handlers to support OpenAPI 3.0.3 spec generation and consumer/provider contract-test generation. Walks interface inheritance for OpenAPI-codegen-first projects.

Data tables:

• io.moderne.prethink.table.EndpointSchemas: Per-endpoint request body and response body bindings, one row per (endpoint, status code) pair. Supports OpenAPI 3.0.3 generation by giving the LLM a full mapping from handler to body DTO FQNs.
• io.moderne.prethink.table.EndpointParameters: Per-parameter detail for REST endpoint handlers - path, query, header, form. Join to service-endpoints.csv via endpointId.

io.moderne.prethink.calm.FindEndpointSecurity

• Find endpoint security
• Per-endpoint security requirements (roles, scopes, raw expressions) extracted from Spring Security (@PreAuthorize/@PostAuthorize/@Secured) and JAX-RS/Jakarta EE (@RolesAllowed/@PermitAll/@DenyAll, jakarta + javax) annotations at method or class level. Joins to service-endpoints.csv via endpointId.

Data tables:

• io.moderne.prethink.table.EndpointSecurity: Per-endpoint security requirements: roles, scopes, and the raw SpEL/permission expressions from @PreAuthorize/@Secured/@RolesAllowed at method or class level.

io.moderne.prethink.calm.FindEntityFrameworkConnections

• Find Entity Framework / Dapper / ADO.NET database access
• Detect Entity Framework Core DbContext subclasses, DbSet<T> properties, [Table]/[Column]/[Key] annotated entity classes, Dapper Query/Execute calls, and raw SqlConnection usage.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindExceptionHandlers

• Find exception handlers
• Capture @ControllerAdvice and controller-local @ExceptionHandler methods, plus JAX-RS/Jakarta EE ExceptionMapper implementations, so that OpenAPI 3.0.3 specs include non-2xx response branches. Emits one row per (scope, exception type, status) triple.

Data tables:

• io.moderne.prethink.table.ExceptionHandlers: Spring @ExceptionHandler/@ControllerAdvice and JAX-RS ExceptionMapper bindings: exception type -> HTTP status -> response body FQN. Used to complete the 'responses' section of an OpenAPI spec with non-2xx branches.

io.moderne.prethink.calm.FindExpressEndpoints

• Find Express endpoints
• Identify REST/HTTP endpoints in Express and Fastify applications. Detects app.get(), router.post(), and similar route definition patterns.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindExternalServiceCalls

• Find external service calls
• Identify outbound HTTP calls to external services. Detects RestTemplate, WebClient, Feign clients, MicroProfile REST Client, Apache HttpClient, OkHttp, and JAX-RS clients.

Data tables:

• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.

io.moderne.prethink.calm.FindFastAPIEndpoints

• Find FastAPI endpoints
• Identify REST/HTTP endpoints in FastAPI applications. Detects @app.get(), @router.post(), and similar route decorator patterns.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindFieldExamplesFromFixtures

• Find field examples from JSON fixtures
• Walk JSON and YAML fixture files under src/test/resources and emit raw (fixturePath, jsonPath, value, valueType) rows so that an LLM can mine realistic example values for OpenAPI specs and contract tests.

Data tables:

• io.moderne.prethink.table.FieldExamples: Raw (fixturePath, jsonPath, value, valueType) rows mined from JSON fixture files. Supply realistic example payloads for contract test generation. LLM correlates jsonPath to DTO fields at spec/contract generation time.

io.moderne.prethink.calm.FindFlaskEndpoints

• Find Flask endpoints
• Identify REST/HTTP endpoints in Flask applications. Detects @app.route(), @blueprint.route(), and Flask 2.0+ shortcut decorators like @app.get() and @app.post().

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindGoDataAssets

• Find Go data assets
• Identify Go structs that carry the data model, classified as entities, documents, or DTOs based on their struct tags (gorm:, db:, bson:, json:) and naming.

Data tables:

• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.

io.moderne.prethink.calm.FindGoDatabaseConnections

• Find Go database connections
• Detect database/sql, GORM, sqlx, pgx, and ent usage in Go source.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindGoGrpcServices

• Find Go gRPC services
• Detect gRPC service registrations via grpc-go RegisterXxxServer calls.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindGoHttpClients

• Find Go HTTP clients
• Detect outbound HTTP calls made through net/http, resty, go-retryablehttp, or imroc/req.

Data tables:

• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.

io.moderne.prethink.calm.FindGoMessagingConnections

• Find Go messaging connections
• Detect Kafka, NATS, RabbitMQ/AMQP client usage in Go source.

Data tables:

• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.

io.moderne.prethink.calm.FindGoProjectMetadata

• Find Go project metadata
• Extract project metadata (module path, go version) from Go go.mod files.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindGoScheduledTasks

• Find Go scheduled tasks
• Detect background work scheduled through robfig/cron, go-co-op/gocron, time.NewTicker/time.Tick, and time.AfterFunc in Go source.

Data tables:

• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.

io.moderne.prethink.calm.FindGoSecurityConfiguration

• Find Go security configuration
• Identify security configuration in Go applications: CORS middleware, JWT / basic / OAuth2 authentication, CSRF protection, security headers, rate limiting, and TLS termination.

Data tables:

• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.

io.moderne.prethink.calm.FindGoServiceEndpoints

• Find Go service endpoints
• Detect HTTP endpoints registered via net/http, gin, echo, chi, gorilla/mux, and fiber routers.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindGoTestCoverage

• Find Go test coverage
• Identify Go test/benchmark/fuzz functions in *_test.go files and record them in the test mapping table.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.calm.FindGraphQLEndpoints

• Find GraphQL endpoints
• Identify GraphQL endpoints exposed by the application. Supports Spring GraphQL, Netflix DGS, and GraphQL Java (graphql-java-tools).

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindGrpcServices

• Find gRPC services
• Identify gRPC service implementations in the application. Detects classes extending generated ImplBase classes and @GrpcService annotations.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindMessagingConnections

• Find messaging connections
• Identify message queue producers and consumers. Detects Kafka (Spring and raw kafka-clients), RabbitMQ, JMS, Spring Cloud Stream, AWS SQS (annotation and raw SDK), Redis pub/sub (Spring Data Redis, Jedis, and Redisson), EJB message-driven beans, and SmallRye Reactive Messaging.

Data tables:

• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.

io.moderne.prethink.calm.FindMongooseSchemas

• Find Mongoose schemas
• Identify Mongoose models and schemas in Node.js applications. Detects mongoose.model() calls and populates the DatabaseConnections table.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindNestJSEndpoints

• Find NestJS endpoints
• Identify REST/HTTP endpoints in NestJS controllers. Detects @Controller, @Get, @Post, @Put, @Delete, and @Patch decorators and populates the ServiceEndpoints data table.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindNodeErrorPatterns

• Find Node.js error patterns
• Identify error handling patterns in Node.js applications. Detects try/catch blocks, infers the handling strategy and log level, and identifies the logging framework from ES imports and require() bindings, reporting console when a catch logs through it.

Data tables:

• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.

io.moderne.prethink.calm.FindNodeHttpClients

• Find Node.js HTTP clients
• Identify HTTP client usage in Node.js applications. Detects axios, fetch, got, and superagent call patterns.

Data tables:

• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.

io.moderne.prethink.calm.FindNodeMessaging

• Find Node.js messaging
• Identify messaging patterns in Node.js applications. Detects KafkaJS, amqplib, and Bull/BullMQ usage.

Data tables:

• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.

io.moderne.prethink.calm.FindNodeProjectMetadata

• Find Node.js project metadata
• Extract project metadata (name, version, description) from Node.js package.json files.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindNodeSecurityConfig

• Find Node.js security configuration
• Identify security middleware in Node.js applications. Detects cors, helmet, passport, and JWT middleware usage.

Data tables:

• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.

io.moderne.prethink.calm.FindNodeTestCoverage

• Find Node.js test coverage
• Identify test methods in Jest, Mocha, and Vitest test files. Detects describe(), it(), and test() blocks and populates the TestMapping table.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.calm.FindPrismaUsage

• Find Prisma usage
• Identify Prisma ORM usage in Node.js applications. Detects prisma.model.findMany() and similar Prisma Client query patterns.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindProjectMetadata

• Find project metadata
• Extract project metadata (artifact ID, group ID, name, description) from Maven pom.xml files.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindPythonGrpcServices

• Find Python gRPC services
• Detect gRPC service implementations in Python by classes subclassing generated *Servicer base classes (grpcio), emitting one endpoint per RPC handler method.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindPythonProjectMetadata

• Find Python project metadata
• Extract project metadata (name, version, description) from Python pyproject.toml files.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindPythonTestCoverage

• Find Python test coverage
• Identify test methods in Python test files. Detects pytest test functions/classes, unittest.TestCase subclasses, and behave/pytest-bdd/lettuce BDD step definitions, and populates the TestMapping table.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.calm.FindRailsDataAssets

• Find Rails data assets
• Identify ActiveRecord entities and their columns from db/schema.rb, or from db/migrate/*.rb when no schema dump is checked in. Association macros declared in app/models enrich the entity they belong to.

Data tables:

• org.openrewrite.prethink.table.DataAssets: Data entities, DTOs, and records that represent the application's data model.

io.moderne.prethink.calm.FindRailsEndpoints

• Find Rails endpoints
• Identify HTTP endpoints declared in a Rails router. Expands resources and resource into their canonical actions, composes paths through namespace, scope, member, collection and concern nesting, expands devise_for, and reconciles every route against the controllers under app/controllers.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindRubyHttpClients

• Find Ruby HTTP clients
• Detect outbound HTTP calls made through Net::HTTP, Faraday, HTTParty, RestClient, http.rb, Typhoeus, or ActiveResource.

Data tables:

• org.openrewrite.prethink.table.ExternalServiceCalls: Outbound HTTP/REST calls to external services.

io.moderne.prethink.calm.FindRubyMessaging

• Find Ruby messaging
• Identify messaging patterns in Ruby applications. Detects Sidekiq, ActiveJob, Resque, ActionCable, Karafka, Racecar, and Shoryuken consumers, including those that reach their framework through a base class of the application's own, along with the call sites that enqueue to them.

Data tables:

• org.openrewrite.prethink.table.MessagingConnections: Message queue producers and consumers in the application.

io.moderne.prethink.calm.FindRubyMicroframeworkEndpoints

• Find Sinatra and Grape endpoints
• Detect HTTP endpoints declared as verb calls with a block in Sinatra and Grape applications, composing Grape paths through namespace, resource and route_param nesting.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindRubyProjectMetadata

• Find Ruby project metadata
• Extract project metadata (name, version, summary) from Ruby gemspecs, from the Rails application module declared in config/application.rb, or failing both from the directory holding a Gemfile. Only the most specific of the three sources present contributes rows, so a repository resolves to one identity.

Data tables:

• org.openrewrite.prethink.table.ProjectMetadata: Project-level identity and structure for each build module. Includes Maven GAV coordinates, display name, description, parent project lineage, and submodule count. Use this to understand what the project is, how it relates to parent projects, and whether it is a multi-module aggregator.

io.moderne.prethink.calm.FindRubyScheduledTasks

• Find Ruby scheduled tasks
• Identify recurring background work in Ruby applications. Detects whenever schedules in config/schedule.rb, sidekiq-cron jobs created through Sidekiq::Cron::Job.create or declared under :schedule: in config/sidekiq.yml, clockwork every declarations in clock.rb, and rufus-scheduler cron/every/in/at calls.

Data tables:

• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.

io.moderne.prethink.calm.FindRubySecurityConfiguration

• Find Ruby security configuration
• Detect Rails authentication, authorization, CSRF, and transport security mechanisms: before_action/skip_before_action authentication filters, protect_from_forgery, Devise model configuration, Pundit, CanCanCan, config.force_ssl, and has_secure_password.

Data tables:

• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.

io.moderne.prethink.calm.FindRubyTestCoverage

• Find Ruby test coverage
• Identify RSpec examples and Minitest tests in Ruby test files and record them in the test mapping table. Joins each test to the class it exercises by Rails naming convention: the constant its describe names, its own class name minus the Test suffix, or the path of the spec, accepted only when a Ruby file declaring that class was scanned.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.calm.FindSQLAlchemyModels

• Find SQLAlchemy and Django ORM models
• Identify ORM model classes in Python applications. Detects SQLAlchemy models with DeclarativeBase inheritance, Flask-SQLAlchemy models with db.Model, and Django ORM models extending models.Model.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindScheduledTasks

• Find scheduled tasks
• Identify scheduled tasks and background jobs in the application. Supports Spring @Scheduled, Quarkus @Scheduled, Quartz Job, Jakarta/Javax EJB Timer, and JobRunr @Recurring annotations, as well as programmatic scheduling through java.util.concurrent.ScheduledExecutorService and Jakarta/Javax EE ManagedScheduledExecutorService.

Data tables:

• io.moderne.prethink.table.ScheduledTasks: Scheduled tasks, cron jobs, and background processing detected in the application.

io.moderne.prethink.calm.FindSecurityConfiguration

• Find security configuration
• Identify security configurations including Spring Security, OAuth2, CORS, Jakarta Security (@RolesAllowed, @PermitAll, @DenyAll), and Quarkus Security settings.

Data tables:

• org.openrewrite.prethink.table.SecurityConfiguration: Security configuration including authentication methods, CORS settings, and OAuth2 configuration.

io.moderne.prethink.calm.FindServerConfiguration

• Find server configuration
• Extract server configuration (port, SSL, context path) from Spring Boot application.properties and application.yml files. Non-Spring server descriptors such as web.xml, jboss-web.xml, or JBoss standalone.xml are not currently supported.

Data tables:

• org.openrewrite.prethink.table.ServerConfiguration: Server configuration properties extracted from application.properties/yml.

io.moderne.prethink.calm.FindServiceComponents

• Find service components
• Identify service layer components across Spring (@Service, @Component), Jakarta/Javax CDI (@Named, @Singleton), Jakarta/Javax EJB (@Stateless, @Stateful), and Micronaut (@Bean) in the application. Excludes controllers and repositories which are handled by dedicated recipes.

Data tables:

• org.openrewrite.prethink.table.ServiceComponents: Service layer components (@Service, @Component, @Named) in the application.

io.moderne.prethink.calm.FindServiceEndpoints

• Find service endpoints
• Identify all REST/HTTP service endpoints exposed by the application. Supports Spring MVC, JAX-RS, Micronaut, and Quarkus REST endpoints. Also walks interface inheritance to detect endpoints in OpenAPI-codegen-first projects where @GetMapping etc. live on the interface methods.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindSignalRHubs

• Find ASP.NET Core SignalR hubs
• Detect SignalR Hub subclasses, their methods (with optional [HubMethodName]), and MapHub<T> registrations.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindSqlUsage

• Find SQL usage
• Locate SQL statements in code and resources, and attribute the physical tables and columns each touches to the class and method that issues it. Emits one row per statement per table, joining sql-anti-patterns.csv on source path and line number, and method-quality-metrics.csv and test-gaps.csv on class name and method signature.

Data tables:

• io.moderne.prethink.table.SqlUsage: Physical tables and columns each SQL statement touches, attributed to the class and method that issues it.

io.moderne.prethink.calm.FindTypeORMEntities

• Find TypeORM entities
• Identify TypeORM entities in Node.js applications. Detects @Entity() decorator on classes and populates the DatabaseConnections table.

Data tables:

• org.openrewrite.prethink.table.DatabaseConnections: Database connections and data access patterns in the application.

io.moderne.prethink.calm.FindWcfEndpoints

• Find WCF service endpoints
• Identify WCF service operations declared via [ServiceContract] and [OperationContract] (System.ServiceModel), including REST-style webHttpBinding operations declared via [WebGet] and [WebInvoke] (System.ServiceModel.Web) with their UriTemplate routes.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindWebFormsEndpoints

• Find ASP.NET Web Forms endpoints
• Identify endpoints in classic ASP.NET (System.Web) applications: Web Forms pages (code-behind classes deriving from System.Web.UI.Page), ASMX web service operations ([WebMethod]), and generic HTTP handlers (IHttpHandler implementations).

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.calm.FindWebSocketEndpoints

• Find WebSocket endpoints
• Identify WebSocket endpoints in the application. Supports Spring WebSocket, Spring STOMP messaging, and Jakarta/Javax WebSocket.

Data tables:

• org.openrewrite.prethink.table.ServiceEndpoints: REST/HTTP endpoints exposed by the application.

io.moderne.prethink.quality.FindClassMetrics

• Find class quality metrics
• Compute per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.

Data tables:

• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.

io.moderne.prethink.quality.FindCodeSmells

• Find code smells
• Detect code smells including God Class, Feature Envy, and Data Class using composite metric thresholds with severity ratings.

Data tables:

• io.moderne.prethink.table.CodeSmells: Detected code smells including God Class, Feature Envy, and Data Class with severity ratings and the metric evidence that triggered detection.

io.moderne.prethink.quality.FindDotnetErrorPatterns

• Find .NET error patterns
• Detect .NET logging frameworks (Microsoft.Extensions.Logging, Serilog, NLog, log4net) and catch-block strategies (swallow, rethrow, log, wrap).

Data tables:

• org.openrewrite.prethink.table.ErrorHandlingPatterns: Error and exception handling patterns detected in the codebase.

io.moderne.prethink.quality.FindDuplicateCode

• Find duplicate code
• Detect duplicate and likely-duplicate code across the codebase by AST-subtree fingerprinting and MinHash/LSH method alignment (zero AI). Reports Type-1 (exact), Type-2 (renamed), and Type-3 (gapped: inserted/removed/edited statements) clone groups ranked by the volume of code that would collapse if the duplication were refactored away.

Data tables:

• io.moderne.prethink.table.DuplicateCode: Groups of duplicated code detected across the codebase by AST-subtree fingerprinting. One row per clone group; sort by redundant volume to surface the highest-value refactoring targets.
• io.moderne.prethink.table.DuplicateCodeOccurrences: One row per individual occurrence of a duplicated fragment, with the machine coordinates a remediation recipe needs to locate and converge each clone. Join to the duplicate code data table on clone group id.

io.moderne.prethink.quality.FindGoCodeSmells

• Find Go code smells
• Detect God Struct, Feature Envy, Large Interface, and Long Function code smells in Go. Data Class is intentionally excluded (idiomatic in Go).

Data tables:

• io.moderne.prethink.table.CodeSmells: Detected code smells including God Class, Feature Envy, and Data Class with severity ratings and the metric evidence that triggered detection.

io.moderne.prethink.quality.FindGoPackageMetrics

• Find Go package quality metrics
• Per-package architectural metrics for Go: afferent/efferent coupling, instability, abstractness (interface ratio), distance from main sequence, and cycle detection.

Data tables:

• io.moderne.prethink.table.PackageQualityMetrics: Per-package architectural metrics including afferent/efferent coupling, instability, abstractness, distance from main sequence, and dependency cycle membership.

io.moderne.prethink.quality.FindGoTypeMetrics

• Find Go type quality metrics
• Compute per-struct code quality metrics for Go including WMC, LCOM4, TCC, CBO, and maintainability index. Aggregates methods with the same receiver type across files.

Data tables:

• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.

io.moderne.prethink.quality.FindMethodComplexity

• Find method complexity
• Compute per-method code quality metrics including cyclomatic complexity, cognitive complexity, max nesting depth, line count, parameter count, ABC metric, and Halstead measures.

Data tables:

• io.moderne.prethink.table.MethodQualityMetrics: Per-method code quality metrics including cyclomatic complexity, cognitive complexity, nesting depth, Halstead measures, and ABC metric.

io.moderne.prethink.quality.FindPackageMetrics

• Find package quality metrics
• Compute per-package architectural quality metrics including afferent/efferent coupling, instability, abstractness, distance from the main sequence, and dependency cycle detection using Tarjan's strongly connected components algorithm.

Data tables:

• io.moderne.prethink.table.PackageQualityMetrics: Per-package architectural metrics including afferent/efferent coupling, instability, abstractness, distance from main sequence, and dependency cycle membership.

io.moderne.prethink.quality.FindRubyMethodComplexity

• Find Ruby method complexity
• Compute per-method code quality metrics for Ruby including cyclomatic complexity, cognitive complexity, max nesting depth, line count, parameter count, ABC metric, and Halstead measures.

Data tables:

• io.moderne.prethink.table.MethodQualityMetrics: Per-method code quality metrics including cyclomatic complexity, cognitive complexity, nesting depth, Halstead measures, and ABC metric.

io.moderne.prethink.quality.FindRubyPackageMetrics

• Find Ruby package quality metrics
• Per-directory architectural metrics for Ruby: afferent/efferent coupling, instability, abstractness (module ratio), distance from main sequence, and cycle detection.

Data tables:

• io.moderne.prethink.table.PackageQualityMetrics: Per-package architectural metrics including afferent/efferent coupling, instability, abstractness, distance from main sequence, and dependency cycle membership.

io.moderne.prethink.quality.FindRubyTypeMetrics

• Find Ruby type quality metrics
• Compute per-class code quality metrics for Ruby including WMC, LCOM4, TCC, CBO, and maintainability index. Aggregates classes and modules of the same name across files.

Data tables:

• io.moderne.prethink.table.ClassQualityMetrics: Per-class code quality metrics including WMC, LCOM4, TCC, CBO, and maintainability index.

io.moderne.prethink.quality.FindSimilarCode

• Find similar code
• Detect structurally similar (but not identical) methods with MinHash/LSH near-duplicate matching over their AST shingles (zero AI), reporting an approximate similarity percentage. Complements exact duplicate detection by surfacing restructured near-duplicates worth consolidating.

Data tables:

• io.moderne.prethink.table.SimilarCode: Groups of structurally similar methods detected by MinHash/LSH near-duplicate matching, with an approximate similarity percentage. Complements exact duplicate detection by finding restructured near-duplicates.

io.moderne.prethink.testing.coverage.FindTestCoverage

• Find test coverage mapping
• Map test methods to their corresponding implementation methods. Uses JavaType.Method matching to determine coverage relationships.

Data tables:

• io.moderne.prethink.table.TestMapping: Maps test methods to the implementation methods they exercise.

io.moderne.prethink.testing.coverage.FindTestGaps

• Find test coverage gaps
• Identify public non-trivial methods that lack test coverage. Reports gaps with cyclomatic complexity and risk scores to help prioritize where to add tests.

Data tables:

• io.moderne.prethink.table.TestGaps: Public non-trivial methods that have no test coverage, ranked by risk score.

io.moderne.prethink.testing.quality.FindDotnetFlakyTestPatterns

• Find .NET flaky test patterns
• Detect Thread.Sleep, Task.Delay (without CancellationToken), and .Result/.Wait() on Task in .NET tests — patterns that cause flakiness or deadlocks.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetFragileTestData

• Find .NET fragile test data
• Detect hardcoded dates/paths/ports, DateTime.Now usage, and Guid.NewGuid/ Random in .NET tests — sources of timing- or environment-dependent flakiness.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetGhostTests

• Find .NET ghost tests
• Detect empty test bodies and suppressed tests ([Ignore], [Fact(Skip=...)]) in .NET tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetOverlyBroadMocks

• Find overly broad mocks in .NET tests
• Detect It.IsAny<T> (Moq), Arg.Any<T> (NSubstitute) and A<T>.Ignored (FakeItEasy) matcher overuse in .NET tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetSilentTestFailures

• Find .NET silent test failures
• Detect .NET test methods with no assertions, and swallowed exceptions inside tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetTestCodeSmells

• Find .NET test code smells
• Detect poor test names, magic numbers in assertions, generic catch in tests, and Debug.Assert misuse in .NET tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindDotnetUnmockedExternalCalls

• Find unmocked external calls in .NET tests
• Detect direct HttpClient/SqlConnection/EF DbContext/File/Socket usage inside .NET unit tests that should typically be mocked.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindFlakyTestPatterns

• Find flaky test patterns
• Detect patterns that commonly cause flaky tests in Java and Python code, including static waits (Thread.sleep, TimeUnit.sleep) and shared mutable state (static non-final fields in test classes).

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindFragileTestData

• Find fragile test data
• Detect hardcoded dates, timing-dependent assertions, and hardcoded ports/paths in test code that may cause flaky or environment-dependent test failures.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGhostTests

• Find ghost tests
• Detect methods that look like tests but will not be executed by the test runner, and tests skipped without a documented reason.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoFlakyTestPatterns

• Find Go flaky test patterns
• Detect time.Sleep and non-deterministic randomness in Go *_test.go files.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoFragileTestData

• Find Go fragile test data
• Detect hardcoded dates, absolute paths, and hardcoded ports in Go tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoGhostTests

• Find Go ghost tests
• Detect empty test bodies and unexplained skips in Go tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoOverlyBroadMocks

• Find Go overly broad mocks
• Detect testify mock.Anything / mock.AnythingOfType usage in Go tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoSilentTestFailures

• Find Go silent test failures
• Detect discarded error returns and assertion-less test bodies in Go tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoTestCodeSmells

• Find Go test code smells
• Detect magic numbers, over-long test names, and over-grown table-driven tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindGoUnmockedExternalCalls

• Find Go unmocked external calls
• Detect net/http, os.Open, net.Dial, sql.Open calls directly in Go tests.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeFlakyTestPatterns

• Find Node.js flaky test patterns
• Detect patterns that commonly cause flaky tests in JavaScript and TypeScript code, including static waits (setTimeout, setInterval), prototype mutation, and shared mutable state (module-scope let/var declarations).

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeFragileTestData

• Find Node.js fragile test data
• Detect hardcoded dates, timing-dependent assertions, and hardcoded ports in JavaScript and TypeScript test files.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeGhostTests

• Find Node.js ghost tests
• Detect skipped tests in JavaScript and TypeScript test files. Flags xtest(), xit(), test.skip(), it.skip(), and describe.skip() calls that lack a documented reason in their description.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeSilentTestFailures

• Find Node.js silent test failures
• Detect silent test failures in JavaScript and TypeScript test files including empty .catch() handlers and test functions missing expect() calls.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeTestCodeSmells

• Find Node.js test code smells
• Detect code smells in JavaScript and TypeScript test files including empty catch blocks and magic numbers.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindNodeUnmockedExternalCalls

• Find unmocked external calls in Node.js tests
• Detect direct HTTP, database, and network calls in JavaScript/TypeScript test files that are not mocked. Integration and e2e test files are excluded.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindOverlyBroadMocks

• Find overly broad mocks
• Detect Mockito stubbing or verification calls that use 3 or more any() matchers, which can hide incorrect arguments and reduce test effectiveness.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindSilentTestFailures

• Find silent test failures
• Detect silent test failures including Java assert keyword usage, swallowed exceptions in try/catch blocks, and test methods missing assertions.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindTestCodeSmells

• Find test code smells
• Detect code smells in test files including empty catch blocks, deprecated test APIs, magic numbers, and poorly named test methods.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

io.moderne.prethink.testing.quality.FindUnmockedExternalCalls

• Find unmocked external calls in tests
• Detect direct HTTP, database, and network calls in unit tests that are not mocked. These cause flaky and slow tests. Integration tests (annotated with @SpringBootTest, @Testcontainers, etc.) are excluded.

Data tables:

• io.moderne.prethink.table.TestQualityIssues: Issues found in test code that may cause flakiness, silent failures, or maintenance burden. Each row includes a rich evidence message with what was found, why it matters, and how to fix it.

rewrite-program-analysis

org.openrewrite.analysis.java.controlflow.search.FindCyclomaticComplexity

• Find cyclomatic complexity
• Calculates the cyclomatic complexity of methods and produces a data table containing the class name, method name, argument types, complexity value, and complexity threshold.

Data tables:

• org.openrewrite.analysis.java.controlflow.table.ComplexityTable: A table of methods and their cyclomatic complexity values.

org.openrewrite.analysis.java.datalineage.TrackDataLineage

• Track data lineage
• Tracks the flow of data from database sources to API sinks to understand data dependencies and support compliance requirements. ## Prerequisites for detecting a data flow All of the following conditions must be met for the recipe to report a flow: 1. The source code must contain at least one method call matching a recognized source (see below). 2. The source code must contain at least one method call matching a recognized sink (see below). 3. The tainted data must propagate from the source to the sink through variable assignments within the same method or via fields across methods in the same compilation unit. 4. No flow breaker (see below) may appear on the path between source and sink. 5. The relevant library types (e.g., java.sql.ResultSet, javax.ws.rs.core.Response) must be on the classpath so that OpenRewrite can resolve types. If types are unresolved, method matchers will not trigger and no flows will be detected. ## Recognized sources (database reads) | Category | Classes | | --- | --- | | JDBC | java.sql.ResultSet | | JPA (javax) | javax.persistence.EntityManager, Query, TypedQuery | | JPA (jakarta) | jakarta.persistence.EntityManager, Query, TypedQuery | | Hibernate | org.hibernate.Session, org.hibernate.query.Query | | Spring Data | org.springframework.data.repository.CrudRepository | | Spring JDBC | org.springframework.jdbc.core.JdbcTemplate | | MyBatis | org.apache.ibatis.session.SqlSession, org.mybatis.spring.SqlSessionTemplate | | MongoDB | com.mongodb.client.MongoCollection, org.springframework.data.mongodb.core.MongoTemplate | | Redis | redis.clients.jedis.Jedis, org.springframework.data.redis.core.RedisTemplate, ValueOperations, HashOperations | | Cassandra | com.datastax.driver.core.Session, org.springframework.data.cassandra.core.CassandraTemplate | | Elasticsearch | org.elasticsearch.client.RestHighLevelClient, org.springframework.data.elasticsearch.core.ElasticsearchTemplate | | Heuristic | Any class with Repository, Dao, or Mapper in its name calling methods starting with find, get, query, search, load, fetch, or select | ## Recognized sinks (API responses) | Category | Classes | | --- | --- | | JAX-RS (javax) | javax.ws.rs.core.Response, Response.ResponseBuilder | | JAX-RS (jakarta) | jakarta.ws.rs.core.Response, Response.ResponseBuilder | | Spring MVC | org.springframework.http.ResponseEntity, ResponseEntity.BodyBuilder | | Servlet (javax) | javax.servlet.http.HttpServletResponse, javax.servlet.ServletOutputStream | | Servlet (jakarta) | jakarta.servlet.http.HttpServletResponse, jakarta.servlet.ServletOutputStream | | Java I/O | java.io.PrintWriter, java.io.Writer, java.io.OutputStream | | Jackson | com.fasterxml.jackson.databind.ObjectMapper, com.fasterxml.jackson.core.JsonGenerator | | Gson | com.google.gson.Gson, com.google.gson.JsonWriter | | GraphQL | graphql.schema.DataFetcher, graphql.schema.PropertyDataFetcher | | Spring WebFlux | ServerResponse, reactor.core.publisher.Mono, reactor.core.publisher.Flux | | gRPC | io.grpc.stub.StreamObserver | | WebSocket | javax.websocket.Session, RemoteEndpoint.Basic, jakarta.websocket.*, org.springframework.web.socket.WebSocketSession | ## Flow breakers Flows are broken by methods matching common sanitization patterns (anonymize, redact, mask, encrypt, hash, sanitize, etc.) or authorization checks (isAuthorized, hasPermission, hasRole, etc.).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.privacy.FindPiiExposure

• Find PII exposure in logs and external APIs
• Detects when Personally Identifiable Information (PII) is exposed through logging statements or sent to external APIs without proper sanitization. This helps prevent data leaks and ensures compliance with privacy regulations like GDPR and CCPA.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindArrayIndexInjection

• Find improper validation of array index
• Detects when user-controlled input flows into array or collection index expressions without proper bounds validation, which could allow out-of-bounds access or denial of service (CWE-129).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindCommandInjection

• Find command injection vulnerabilities
• Detects when user-controlled input flows into system command execution methods like Runtime.exec() or ProcessBuilder, which could allow attackers to execute arbitrary commands.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindInsecureCryptoComparison

• Find non-constant-time comparison of cryptographic digests
• Detects when the output of MessageDigest.digest(..) or Mac.doFinal(..) flows into Arrays.equals(byte[], byte[]), a non-constant-time comparison that is vulnerable to timing attacks (CWE-208). Use MessageDigest.isEqual(byte[], byte[]) for security-sensitive byte-array comparisons.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindJndiInjection

• Find JNDI injection vulnerabilities
• Detects when user-controlled input flows into JNDI lookup operations without proper validation, which could allow an attacker to connect to malicious naming/directory services (CWE-99).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindLdapInjection

• Find LDAP injection vulnerabilities
• Finds LDAP injection vulnerabilities by tracking tainted data flow from user input to LDAP queries.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindLogInjection

• Find log injection vulnerabilities
• Detects when user-controlled input flows into logging methods without sanitization, which could allow attackers to forge log entries by injecting newline characters.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindPathTraversal

• Find path traversal vulnerabilities
• Detects potential path traversal vulnerabilities where user input flows to file system operations without proper validation.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindProcessControlInjection

• Find process control vulnerabilities
• Detects when user-controlled input flows into native library loading methods without proper validation, which could allow an attacker to load arbitrary native code (CWE-114).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindSecurityVulnerabilities

• Find security vulnerabilities using taint analysis
• Identifies potential security vulnerabilities where untrusted data from sources flows to sensitive sinks without proper sanitization.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindSqlInjection

• Find SQL injection vulnerabilities
• Detects potential SQL injection vulnerabilities where user input flows to SQL execution methods without proper sanitization.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindUnencryptedPiiStorage

• Find unencrypted PII storage
• Identifies when personally identifiable information (PII) is stored in databases, files, or other persistent storage without encryption.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindUnsafeReflectionInjection

• Find unsafe reflection vulnerabilities
• Detects when user-controlled input flows into reflection-based class loading or instantiation without proper validation, which could allow an attacker to instantiate arbitrary classes (CWE-470).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindXssVulnerability

• Find XSS vulnerabilities
• Detects potential cross-site scripting vulnerabilities where user input flows to output methods without proper sanitization.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.analysis.java.security.FindXxeVulnerability

• Find XXE vulnerabilities
• Locates XML parsers that are not configured to prevent XML External Entity (XXE) attacks.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

rewrite-react

org.openrewrite.react.search.FindPropUsage

• Find React prop usage
• Locates usages of a specific prop of a React component.

Data tables:

• org.openrewrite.react.table.PropUsages: Information about how specific component props are used.

org.openrewrite.react.search.FindReactComponent

• Find React component
• Locates usages of React components across the codebase including JSX elements and other references. If componentName is null, finds all React components.

Data tables:

• org.openrewrite.react.table.ReactComponentUses: Information about React component usages including imports, JSX tags, and other references.

rewrite-release-metromap

io.moderne.recipe.releasemetro.FindGradleParentRelationships

• Find Gradle root project to subproject relationships
• Gradle has no parent-project concept like Maven. The closest analog is the root project of a multi-project build, so this recipe records the GAV coordinates of each subproject paired with the root project.

Data tables:

• io.moderne.recipe.releasemetro.table.ParentRelationships: Relationships between Maven child modules and their parent POMs, or Gradle subprojects and their root project.

io.moderne.recipe.releasemetro.FindGradleProjectIDs

• Find Gradle project IDs
• Find Gradle project IDs in build.gradle files to determine the project ID.

Data tables:

• io.moderne.recipe.releasemetro.table.ProjectCoordinates: Maven Modules or Gradle (sub-)project groupId and artifactId.

io.moderne.recipe.releasemetro.FindMavenParentRelationships

• Find Maven parent relationships
• Find Maven parent POM relationships to understand project hierarchies in multi-module builds.

Data tables:

• io.moderne.recipe.releasemetro.table.ParentRelationships: Relationships between Maven child modules and their parent POMs, or Gradle subprojects and their root project.

io.moderne.recipe.releasemetro.FindMavenProjectIDs

• Find maven project IDs
• Find Maven group Id and artifactId in pom.xml files to determine the project ID.

Data tables:

• io.moderne.recipe.releasemetro.table.ProjectCoordinates: Maven Modules or Gradle (sub-)project groupId and artifactId.

io.moderne.recipe.releasemetro.FindPotentiallyUnusedDependencies

• Find potentially unused dependencies
• Collects import information to help identify potentially unused dependencies.

Data tables:

• io.moderne.recipe.releasemetro.table.UnusedDependencies: Dependencies that are declared in build files but may not be used based on import analysis.

io.moderne.recipe.releasemetro.ReleaseMetroPlan

• Analyse Organization's Release Train Metro Plan
• Gathers the basic information to create and understand the organizations release train metro plan.

Data tables:

• io.moderne.recipe.releasemetro.table.ProjectCoordinates: Maven Modules or Gradle (sub-)project groupId and artifactId.
• io.moderne.recipe.releasemetro.table.ParentRelationships: Relationships between Maven child modules and their parent POMs, or Gradle subprojects and their root project.
• io.moderne.recipe.releasemetro.table.UnusedDependencies: Dependencies that are declared in build files but may not be used based on import analysis.
• org.openrewrite.maven.table.DependenciesDeclared: Direct (first-order) dependencies declared by the project.

rewrite-spring

io.moderne.java.spring.boot3.SpringBoot3BestPractices

• Spring Boot 3.5 best practices
• Applies best practices to Spring Boot 3.5+ applications.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot3.UpgradeGradle8Spring34

• Upgrade Gradle 8 to 8.4+ for Spring Boot 3.4
• Spring Boot 3.4 requires Gradle 8.4+.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot3.UpgradeSpringBoot_3_0

• Migrate to Spring Boot 3.0 (Moderne Edition)
• Migrate applications to the latest Spring Boot 3.0 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations that are required as part of the migration to Spring Boot 3.0, including the Tomcat 10.1 upgrade which removes LegacyCookieProcessor.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot3.UpgradeSpringBoot_3_4

• Migrate to Spring Boot 3.4 (Moderne Edition)
• Migrate applications to the latest Spring Boot 3.4 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 3.4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot3.UpgradeSpringBoot_3_5

• Migrate to Spring Boot 3.5 (Moderne Edition)
• Migrate applications to the latest Spring Boot 3.5 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 3.5.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot4.SpringBoot4BestPractices

• Spring Boot 4.0 best practices
• Applies best practices to Spring Boot 4.+ applications.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot4.UpgradeSpringBoot_4_0

• Migrate to Spring Boot 4.0 (Moderne Edition)
• Migrate applications to the latest Spring Boot 4.0 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 4.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot4.UpgradeSpringBoot_4_1

• Migrate to Spring Boot 4.1
• Migrate applications to the latest Spring Boot 4.1 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 4.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.boot4.UpgradeToJava21WhenUsingJooq

• Upgrade to Java 21 when using jOOQ
• Spring Boot 4 keeps a Java 17 baseline, but the jOOQ version it manages (3.20+) requires Java 21 or later. This recipe upgrades modules that depend on jOOQ to Java 21 so they remain compatible after the Spring Boot 4.0 upgrade. Modules that do not use jOOQ are left on their current Java baseline. See https://github.com/spring-projects/spring-boot/issues/48619.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.framework.FindDeprecatedPathMatcherUsage

• Find deprecated PathMatcher usage
• In Spring Framework 7.0, PathMatcher and AntPathMatcher are deprecated in favor of PathPatternParser. This recipe finds usages of the deprecated AntPathMatcher class that may require manual migration to PathPatternParser.

Data tables:

• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

io.moderne.java.spring.framework.UpgradeSpringFramework_6_0

• Migrate to Spring Framework 6.0 (Moderne Edition)
• Migrate applications to the latest Spring Framework 6.0 release. Chains through UpgradeSpringFramework_5_3 (and transitively _5_0/_4_0/_3_0) and layers Spring Integration XML attribute migrations on top of the OSS Spring Framework 6.0 upgrade. The OSS recipe handles the org.springframework:* version bump and Jakarta EE 10 package moves; this composite additionally bumps org.springframework.security:* to 6.0.x (Spring Security tracks Spring's major) and cleans up Spring Integration XML configurations.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.moderne.java.spring.framework7.UpgradeSpringFramework_7_0

• Migrate to Spring Framework 7.0
• Migrates applications to Spring Framework 7.0. This recipe applies all necessary changes including API migrations, removed feature detection, and configuration updates.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-vulncheck

io.moderne.vulncheck.FixVulnCheckVulnerabilities

• Use VulnCheck Exploit Intelligence to fix vulnerabilities
• This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from VulnCheck Vulnerability Intelligence. The recipe has an option to limit fixes to only those vulnerabilities that have evidence of exploitation at various levels of severity.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• io.moderne.vulncheck.table.VulnerabilityReportWithExploits: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs and enriched by VulnCheck exploit data.

org.openrewrite

rewrite-cobol

org.openrewrite.cobol.search.FindCopybook

• Find copybook usage
• Find all copy statements with the copybook name.

Data tables:

• org.openrewrite.cobol.table.CopybookSource: Information about copybook references in a COBOL source.

org.openrewrite.cobol.search.FindIndicators

• Find indicators
• Find matching indicators. Currently, this recipe will not mark indicators on copybook code.

Data tables:

• org.openrewrite.cobol.table.IndicatorSearchResult: Indicator area matches found in COBOL source code.

org.openrewrite.cobol.search.FindReference

• Find matching identifiers in COBOL, copybooks, and JCL
• Finds an identifier by an exact match or regex pattern in COBOL, copybooks, and/or JCL.

Data tables:

• org.openrewrite.cobol.table.ReferenceSearchResult: Identifier references found in COBOL, copybook, and JCL sources.

org.openrewrite.cobol.search.FindRelationships

• Find COBOL relationships
• Build a list of relationships for diagramming and exploration.

Data tables:

• org.openrewrite.cobol.table.CobolRelationships: Relationships between different COBOL resources.

org.openrewrite.cobol.search.FindWord

• Find matching words in the source code
• Search for COBOL words based on a search term.

Data tables:

• org.openrewrite.cobol.table.WordSearchResult: Words in COBOL source code that match the search criteria.

org.openrewrite.jcl.search.FindWord

• Find matching words in JCL source code
• Search for JCL words based on a search term.

Data tables:

• org.openrewrite.jcl.table.JclWordSearchResult: Words in JCL source code that match the search criteria.

rewrite-core

org.openrewrite.FindCollidingSourceFiles

• Find colliding source files
• Finds source files which share a path with another source file. There should always be exactly one source file per path within a repository. This is a diagnostic for finding problems in OpenRewrite parsers/build plugins.

Data tables:

• org.openrewrite.table.CollidingSourceFiles: Source files that have the same relative path.

org.openrewrite.FindDeserializationErrors

• Find deserialization errors
• Produces a data table collecting all deserialization errors of serialized LSTs.

Data tables:

• org.openrewrite.table.DeserializationErrorTable: Table collecting any LST deserialization errors.

org.openrewrite.FindGitProvenance

• Show Git source control metadata
• List out the contents of each unique GitProvenance marker in the set of source files. When everything is working correctly, exactly one such marker should be printed as all source files are expected to come from the same repository / branch / commit hash.

Data tables:

• org.openrewrite.table.DistinctGitProvenance: List out the contents of each unique GitProvenance marker in the set of source files. When everything is working correctly, exactly one such marker should be printed as all source files are expected to come from the same repository / branch / commit hash.

org.openrewrite.FindLstProvenance

• Find LST provenance
• Produces a data table showing what versions of OpenRewrite/Moderne tooling was used to produce a given LST.

Data tables:

• org.openrewrite.table.LstProvenanceTable: Table showing which tools were used to produce LSTs.

org.openrewrite.FindParseFailures

• Find source files with ParseExceptionResult markers
• This recipe explores parse failures after an LST is produced for classifying the types of failures that can occur and prioritizing fixes according to the most common problems.

Data tables:

• org.openrewrite.table.ParseFailures: A list of files that failed to parse along with stack traces of their failures.

org.openrewrite.FindSourceFiles

• Find files
• Find files by source path. Paths are always interpreted as relative to the repository root.

Data tables:

• org.openrewrite.table.SourcesFiles: Source files that matched some criteria.

org.openrewrite.FindStyles

• Find styles
• Find and report the styles attached to each source file. Styles are output as valid OpenRewrite style YAML that can be used directly in rewrite.yml configuration.

Data tables:

• org.openrewrite.table.StylesInUse: Styles detected on each source file.

org.openrewrite.ListRuntimeClasspath

• List runtime classpath
• A diagnostic utility which emits the runtime classpath to a data table.

Data tables:

• org.openrewrite.table.ClasspathReport: Contains a report of the runtime classpath and any other jars found inside each classpath entry.

org.openrewrite.search.FindCommitters

• Find committers on repositories
• List the committers on a repository.

Data tables:

• org.openrewrite.table.DistinctCommitters: The distinct set of committers per repository.
• org.openrewrite.table.CommitsByDay: The commit activity by day by committer.

org.openrewrite.search.FindParseToPrintInequality

• Find parse to print inequality
• OpenRewrite Parser implementations should produce SourceFile objects whose printAll() method should be byte-for-byte equivalent with the original source file. When this isn't true, recipes can still run on the SourceFile and even produce diffs, but the diffs would fail to apply as a patch to the original source file. Most Parser use Parser#requirePrintEqualsInput to produce a ParseError when they fail to produce a SourceFile that is print idempotent.

Data tables:

• org.openrewrite.table.ParseToPrintInequalities: A list of files that parsers produced SourceFile which, when printed, didn't match the original source code.

org.openrewrite.text.Find

• Find text
• Textual search, optionally using Regular Expression (regex) to query.

Data tables:

• org.openrewrite.table.TextMatches: Lines matching simple text search.

rewrite-docker

org.openrewrite.docker.DockerBestPractices

• Apply Docker best practices
• Apply a set of Docker best practices to Dockerfiles. This recipe applies security hardening, build optimization, and maintainability improvements based on CIS Docker Benchmark and industry best practices.

Data tables:

• org.openrewrite.docker.table.EolDockerImages: Records Docker base images that have reached end-of-life.

org.openrewrite.docker.DockerSecurityBestPractices

• Apply Docker security best practices
• Apply security-focused Docker best practices to Dockerfiles. This includes running as a non-root user (CIS 4.1) and using COPY instead of ADD where appropriate (CIS 4.9).

Data tables:

• org.openrewrite.docker.table.EolDockerImages: Records Docker base images that have reached end-of-life.

org.openrewrite.docker.search.FindBaseImages

• Find Docker base images
• Find all base images (FROM instructions) in Dockerfiles.

Data tables:

• org.openrewrite.docker.table.BaseImages: Records the base images found in Dockerfiles.

org.openrewrite.docker.search.FindEndOfLifeImages

• Find end-of-life Docker base images
• Identifies Docker base images that have reached end-of-life. Using EOL images poses security risks as they no longer receive security updates. Detected images include EOL versions of Debian, Ubuntu, Alpine, Python, and Node.js.

Data tables:

• org.openrewrite.docker.table.EolDockerImages: Records Docker base images that have reached end-of-life.

org.openrewrite.docker.search.FindExposedPorts

• Find exposed ports
• Find all EXPOSE instructions in Dockerfiles and report the exposed ports.

Data tables:

• org.openrewrite.docker.table.ExposedPorts: Records all ports exposed in EXPOSE instructions in Dockerfiles.

rewrite-go

org.openrewrite.golang.search.DependencyInsight

• Go dependency insight
• Find direct and transitive Go module dependencies matching a module path pattern. Results include dependencies that either directly match or transitively include a matching dependency.

Data tables:

• org.openrewrite.golang.table.GoDependenciesInUse: Direct and transitive dependencies in use in Go modules.

rewrite-gradle

org.openrewrite.gradle.AddDependency

• Add Gradle dependency
• Add a gradle dependency to a build.gradle file in the correct configuration based on where it is used.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.AddJUnitPlatformLauncher

• Add JUnit Platform Launcher
• Add the JUnit Platform Launcher to the buildscript dependencies.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.AddPlatformDependency

• Add Gradle platform dependency
• Add a gradle platform dependency to a build.gradle file in the correct configuration based on where it is used.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.ChangeDependency

• Change Gradle dependency
• Change a Gradle dependency coordinates. The newGroupId or newArtifactId MUST be different from before.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.ChangeManagedDependency

• Change Gradle managed dependency
• Change a Gradle managed dependency coordinates. The newGroupId or newArtifactId MUST be different from before. For now, only Spring Dependency Management Plugin entries are supported and no other forms of managed dependencies (yet).

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.GradleBestPractices

• Apply Gradle best practices
• Apply a set of Gradle best practices to the build files, for more efficient and idiomatic builds.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.MigrateToGradle8

• Migrate to Gradle 8 from Gradle 7
• Migrate to version 8.x. See the Gradle upgrade guide from version 7.x to 8.0 and version 8.x to latest for more information.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.MigrateToGradle9

• Migrate to Gradle 9 from Gradle 8
• Migrate to version 9.x. See the Gradle upgrade guide from version 8.x to 9.0 for more information.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.UpgradeDependencyVersion

• Upgrade Gradle dependency versions
• Upgrade the version of a dependency in a build.gradle file. Supports updating dependency declarations of various forms: * String notation: "group:artifact:version" * Map notation: group: 'group', name: 'artifact', version: 'version' Can update version numbers which are defined earlier in the same file in variable declarations.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.UpgradeTransitiveDependencyVersion

• Upgrade transitive Gradle dependencies
• Upgrades the version of a transitive dependency in a Gradle build file. There are many ways to do this in Gradle, so the mechanism for upgrading a transitive dependency must be considered carefully depending on your style of dependency management.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.plugins.AddDevelocityGradlePlugin

• Add the Develocity Gradle plugin
• Add the Develocity Gradle plugin to settings.gradle files.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.plugins.ChangePlugin

• Change a Gradle plugin
• Changes the selected Gradle plugin to the new plugin.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.plugins.ChangePluginVersion

• Change a Gradle plugin version by id
• Change a Gradle plugin by id to a later version.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.plugins.MigrateGradleEnterpriseToDevelocity

• Migrate from Gradle Enterprise to Develocity
• Migrate from the Gradle Enterprise Gradle plugin to the Develocity Gradle plugin.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.plugins.UpgradePluginVersion

• Update a Gradle plugin by id
• Update a Gradle plugin by id to a later version defined by the plugins DSL. To upgrade a plugin dependency defined by buildscript.dependencies, use the UpgradeDependencyVersion recipe instead.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.gradle.search.DependencyInsight

• Gradle dependency insight
• Find direct and transitive dependencies matching a group, artifact, resolved version, and optionally a configuration name. Results include dependencies that either directly match or transitively include a matching dependency.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.
• org.openrewrite.maven.table.ExplainDependenciesInUse: A dependency graph explainer similar to that shown by gradle dependencyInsight for each matching dependency. This table will contain a row per matching dependency per configuration per (sub)project.

org.openrewrite.gradle.search.EffectiveGradlePluginRepositories

• List effective Gradle plugin repositories
• Lists the Gradle plugin repositories that would be used for plugin resolution, in order of precedence. This includes Maven repositories defined in the settings.gradle pluginManagement section and build.gradle buildscript repositories as determined when the LST was produced.

Data tables:

• org.openrewrite.maven.search.EffectiveMavenRepositoriesTable: Table showing which Maven repositories were used in dependency resolution for this POM.

org.openrewrite.gradle.search.EffectiveGradleRepositories

• List effective Gradle project repositories
• Lists the Gradle project repositories that would be used for dependency resolution, in order of precedence. This includes Maven repositories defined in the Gradle build files and settings as determined when the LST was produced.

Data tables:

• org.openrewrite.maven.search.EffectiveMavenRepositoriesTable: Table showing which Maven repositories were used in dependency resolution for this POM.

org.openrewrite.gradle.search.FindDependency

• Find Gradle dependency
• Finds dependencies declared in gradle build files. Each match is also recorded as a row in the DependenciesDeclared data table. See the reference on Gradle configurations or the diagram below for a description of what configuration to use. A project's compile and runtime classpath is based on these configurations. <img alt="Gradle compile classpath" src="https://docs.gradle.org/current/userguide/img/java-library-ignore-deprecated-main.png" width="200px"/> A project's test classpath is based on these configurations. <img alt="Gradle test classpath" src="https://docs.gradle.org/current/userguide/img/java-library-ignore-deprecated-test.png" width="200px"/>.

Data tables:

• org.openrewrite.maven.table.DependenciesDeclared: Direct (first-order) dependencies declared by the project.

org.openrewrite.gradle.search.FindGradleWrapper

• Find Gradle wrappers
• Find Gradle wrappers.

Data tables:

• org.openrewrite.gradle.table.GradleWrappersInUse: Gradle wrappers in use.

org.openrewrite.gradle.search.FindJVMTestSuites

• Find Gradle JVMTestSuite plugin configuration
• Find Gradle JVMTestSuite plugin configurations and produce a data table.

Data tables:

• org.openrewrite.gradle.table.JVMTestSuitesDefined: The Gradle JVMTestSuites that are configured in a build.

org.openrewrite.gradle.search.FindRepositoryOrder

• Gradle repository order
• Determine the order in which dependencies will be resolved for each build.gradle based on its defined repositories as determined when the LST was produced.

Data tables:

• org.openrewrite.maven.table.MavenRepositoryOrder: The order in which dependencies will be resolved for each pom.xml based on its defined repositories and effective settings.xml.

rewrite-java

org.openrewrite.java.ai.ClassDefinitionLength

• Calculate token length of classes
• Locates class definitions and predicts the number of token in each.

Data tables:

• org.openrewrite.java.table.TokenCount: The number of tokens from a code snippet

org.openrewrite.java.ai.MethodDefinitionLength

• Calculate token length of method definitions
• Locates method definitions and predicts the number of token in each.

Data tables:

• org.openrewrite.java.table.TokenCount: The number of tokens from a code snippet

org.openrewrite.java.search.ClasspathTypeCounts

• Study the size of the classpath by source set
• Emit one data table row per source set in a project, with the number of types in the source set.

Data tables:

• org.openrewrite.java.table.ClasspathTypeCount: The number of types in each source set in a project's classpath.

org.openrewrite.java.search.FindClassHierarchy

• Find class hierarchy
• Discovers all class declarations within a project, recording which files they appear in, their superclasses, and interfaces. That information is then recorded in a data table.

Data tables:

• org.openrewrite.java.table.ClassHierarchy: Record the classes

org.openrewrite.java.search.FindCompileErrors

• Find compile errors
• Compile errors result in a particular LST structure that can be searched for.

Data tables:

• org.openrewrite.java.table.CompileErrors: The source code of compile errors.

org.openrewrite.java.search.FindDeprecatedMethods

• Find uses of deprecated methods
• Find uses of deprecated methods in any API.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.search.FindDeprecatedUses

• Find uses of deprecated classes, methods, and fields
• Find deprecated uses of methods, fields, and types. Optionally ignore those classes that are inside deprecated scopes.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.search.FindDistinctMethods

• Find distinct methods in use
• A sample of every distinct method in use in a repository. The code sample in the method calls data table will be a representative use of the method, though there may be many other such uses of the method.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.search.FindFieldsOfType

• Find fields of type
• Finds declared fields matching a particular class name.

Data tables:

• org.openrewrite.java.table.FieldsOfTypeUses: Information about fields that match a specific type.

org.openrewrite.java.search.FindMethods

• Find method usages
• Find method calls by pattern.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.search.FindSymbols

• Find symbols
• Lists all symbols (classes, methods, fields, etc.) declared in the codebase. Results are emitted into a data table with symbol kind, name, parent type, signature, and visibility.

Data tables:

• org.openrewrite.java.table.SymbolsTable: All symbols (classes, methods, fields) declared in the codebase.

org.openrewrite.java.search.FindTypeMappings

• Find type mappings
• Study the frequency of J types and their JavaType type attribution.

Data tables:

• org.openrewrite.java.table.TypeMappings: The types mapped to J trees.

org.openrewrite.java.search.FindTypes

• Find types
• Find type references by name.

Data tables:

• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

rewrite-javascript

org.openrewrite.javascript.AddDependency

• Add npm dependency
• 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.

Data tables:

• org.openrewrite.javascript.table.NodeLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.javascript.ChangeDependency

• Change npm dependency
• 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.

Data tables:

• org.openrewrite.javascript.table.NodeLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.javascript.RemoveDependency

• Remove npm dependency
• 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.

Data tables:

• org.openrewrite.javascript.table.NodeLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.javascript.UpgradeDependencyVersion

• Upgrade npm dependency version
• 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.

Data tables:

• org.openrewrite.javascript.table.NodeLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.javascript.UpgradeTransitiveDependencyVersion

• Upgrade transitive npm dependency
• 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.

Data tables:

• org.openrewrite.javascript.table.NodeLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.javascript.search.DependencyInsight

• Node.js dependency insight
• Find direct and transitive npm dependencies matching a package name pattern. Results include dependencies that either directly match or transitively include a matching dependency.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

rewrite-kotlin

org.openrewrite.kotlin.FindKotlinSources

• Find Kotlin sources and collect data metrics
• Use data table to collect source files types and counts of files with extensions .kt.

Data tables:

• org.openrewrite.kotlin.table.KotlinSourceFile: Kotlin sources present in LSTs on the SAAS.

rewrite-maven

org.openrewrite.maven.AddDependency

• Add Maven dependency
• Add a Maven dependency to a pom.xml file in the correct scope based on where it is used.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.AddManagedDependency

• Add managed Maven dependency
• Add a managed Maven dependency to a pom.xml file.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.AddParentPom

• Add Maven parent
• Add a parent pom to a Maven pom.xml. Does nothing if a parent pom is already present.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.BestPractices

• Apache Maven best practices
• Applies best practices to Maven POMs.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.ChangeDependencyGroupIdAndArtifactId

• Change Maven dependency
• Change a Maven dependency coordinates. The newGroupId or newArtifactId MUST be different from before. Matching <dependencyManagement> coordinates are also updated if a newVersion or versionPattern is provided. Exclusions that reference the old dependency coordinates are preserved, and a sibling exclusion for the new coordinates is added alongside them.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.ChangeManagedDependencyGroupIdAndArtifactId

• Change Maven managed dependency groupId, artifactId and optionally the version
• Change the groupId, artifactId and optionally the version of a specified Maven managed dependency.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.ChangeParentPom

• Change Maven parent
• Change the parent pom of a Maven pom.xml by matching the existing parent via groupId and artifactId, and updating it to a new groupId, artifactId, version, and optional relativePath. Also updates the project to retain dependency management and properties previously inherited from the old parent that are no longer provided by the new parent. Removes redundant dependency versions already managed by the new parent.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.ChangePluginGroupIdAndArtifactId

• Change Maven plugin group and artifact ID
• Change the groupId and/or the artifactId of a specified Maven plugin. Optionally update the plugin version, which may be given as an exact version or as a node-style semver selector resolved against the new plugin's available versions.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.MigrateToMaven4

• Migrate to Maven 4
• Migrates Maven POMs from Maven 3 to Maven 4, addressing breaking changes and deprecations. This recipe updates property expressions, lifecycle phases, removes duplicate plugin and dependency declarations, upgrades plugins known to fail under Maven 4, switches repository URLs to HTTPS, and replaces removed properties to ensure compatibility with Maven 4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.ReproducibleBuilds

• Apache Maven reproducible builds
• Configure a Maven project for reproducible builds: pin dependency and plugin versions, set project.build.outputTimestamp, set explicit UTF-8 source encoding, and upgrade core plugins to versions that honor the output timestamp.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.UpgradeDependencyVersion

• Upgrade Maven dependency version
• Upgrade the version of a dependency by specifying a group and (optionally) an artifact using Node Semver advanced range selectors, allowing more precise control over version updates to patch or minor releases.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.UpgradePluginVersion

• Upgrade Maven plugin version
• Upgrade the version of a plugin using Node Semver advanced range selectors, allowing more precise control over version updates to patch or minor releases.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.UpgradePluginsForMaven4

• Upgrade plugins that are incompatible with Maven 4
• Upgrades plugins that are known to fail under Maven 4, using the minimum working versions applied by Apache's own mvnup upgrade --plugins as a floor while accepting any newer release within the same major version. Plugins already at or above that floor are upgraded to the latest such release; plugins that declare no version are left alone. quarkus-maven-plugin is held at its floor, as its version is coupled to the Quarkus platform BOM. Plugin dependencies known to break Maven 4 are upgraded as well.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.UpgradeTransitiveDependencyVersion

• Upgrade transitive Maven dependencies
• Upgrades the version of a transitive dependency in a Maven pom file. Leaves direct dependencies unmodified. When the transitive dependency's version is already governed by a plain <dependencyManagement> entry in the project, that entry is upgraded in place rather than adding a duplicate; otherwise (including a version supplied by an imported BOM) a new managed dependency is added. Can be paired with the regular Upgrade Dependency Version recipe to upgrade a dependency everywhere, regardless of whether it is direct or transitive.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.cleanup.ExplicitDependencyVersion

• Add explicit dependency versions
• Add explicit dependency versions to POMs for reproducibility, as the LATEST and RELEASE version keywords are deprecated.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.maven.search.DependencyInsight

• Maven dependency insight
• Find direct and transitive dependencies matching a group, artifact, and scope. Results include dependencies that either directly match or transitively include a matching dependency.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.
• org.openrewrite.maven.table.ExplainDependenciesInUse: A dependency graph explainer similar to that shown by gradle dependencyInsight for each matching dependency. This table will contain a row per matching dependency per configuration per (sub)project.

org.openrewrite.maven.search.EffectiveDependencies

• Effective dependencies
• Emit the data of binary dependency relationships.

Data tables:

• org.openrewrite.maven.table.DependencyGraph: Relationships between dependencies.

org.openrewrite.maven.search.EffectiveManagedDependencies

• Effective managed dependencies
• Emit the data of binary dependency relationships.

Data tables:

• org.openrewrite.maven.table.ManagedDependencyGraph: Relationships between POMs and their ancestors that define managed dependencies.

org.openrewrite.maven.search.EffectiveMavenRepositories

• List effective Maven repositories
• Lists the Maven repositories that would be used for dependency resolution, in order of precedence. This includes Maven repositories defined in the Maven settings file (and those contributed by active profiles) as determined when the LST was produced.

Data tables:

• org.openrewrite.maven.search.EffectiveMavenRepositoriesTable: Table showing which Maven repositories were used in dependency resolution for this POM.

org.openrewrite.maven.search.FindDependency

• Find Maven dependency
• Finds first-order dependency uses, i.e. dependencies that are defined directly in a project. Each match is also recorded as a row in the DependenciesDeclared data table.

Data tables:

• org.openrewrite.maven.table.DependenciesDeclared: Direct (first-order) dependencies declared by the project.

org.openrewrite.maven.search.FindMavenSettings

• Find effective maven settings
• List the effective maven settings file for the current project.

Data tables:

• org.openrewrite.maven.table.EffectiveMavenSettings: The maven settings file used by each pom.

org.openrewrite.maven.search.FindProperties

• Find Maven project properties
• Finds the specified Maven project properties within a pom.xml.

Data tables:

• org.openrewrite.maven.table.MavenProperties: Property and value.

org.openrewrite.maven.search.FindRepositoryOrder

• Maven repository order
• Determine the order in which dependencies will be resolved for each pom.xml based on its defined repositories and effective settings.xml.

Data tables:

• org.openrewrite.maven.table.MavenRepositoryOrder: The order in which dependencies will be resolved for each pom.xml based on its defined repositories and effective settings.xml.

org.openrewrite.maven.search.ParentPomInsight

• Maven parent insight
• Find Maven parents matching a groupId and artifactId.

Data tables:

• org.openrewrite.maven.table.ParentPomsInUse: Projects, GAVs and relativePaths for Maven parent POMs in use.

rewrite-python

org.openrewrite.python.AddDependency

• Add Python dependency
• Add a dependency to a Python project. Supports pyproject.toml (with scope/group targeting), requirements.txt, and Pipfile. For pyproject.toml, uv.lock, poetry.lock, and pdm.lock are regenerated natively without executing the package manager. For Pipfile, Pipfile.lock is regenerated natively by consulting the project's package index over the network. Not safe to use as a precondition: invokes the package manager or the network and publishes per-project state shared with other dependency recipes.

Data tables:

• org.openrewrite.python.table.PythonLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.python.ChangeDependency

• Change Python dependency
• Change a dependency to a different package. Supports pyproject.toml, requirements.txt, and Pipfile. Searches all dependency scopes. For pyproject.toml, uv.lock, poetry.lock, and pdm.lock are regenerated natively without executing the package manager. For Pipfile, Pipfile.lock is regenerated natively by consulting the project's package index over the network. Not safe to use as a precondition: invokes the package manager or the network and publishes per-project state shared with other dependency recipes.

Data tables:

• org.openrewrite.python.table.PythonLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.python.RemoveDependency

• Remove Python dependency
• Remove a dependency from a Python project. Supports pyproject.toml (with scope/group targeting), requirements.txt, and Pipfile. For pyproject.toml, uv.lock, poetry.lock, and pdm.lock are regenerated natively without executing the package manager. For Pipfile, Pipfile.lock is regenerated natively by consulting the project's package index over the network. Not safe to use as a precondition: invokes the package manager or the network and publishes per-project state shared with other dependency recipes.

Data tables:

• org.openrewrite.python.table.PythonLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.python.UpgradeDependencyVersion

• Upgrade Python dependency version
• Upgrade the version constraint for a dependency. Supports pyproject.toml (with scope/group targeting), requirements.txt, and Pipfile. For pyproject.toml, uv.lock, poetry.lock, and pdm.lock are regenerated natively without executing the package manager. For Pipfile, Pipfile.lock is regenerated natively by consulting the project's package index over the network. Not safe to use as a precondition: invokes the package manager or the network and publishes per-project state shared with other dependency recipes.

Data tables:

• org.openrewrite.python.table.PythonLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.python.UpgradeTransitiveDependencyVersion

• Upgrade transitive Python dependency version
• Pin a transitive dependency version using the strategy appropriate for the file type and package manager. For pyproject.toml: uv uses [tool.uv].constraint-dependencies, PDM uses [tool.pdm.overrides], and other managers add a direct dependency. For requirements.txt and Pipfile: appends the dependency. For pyproject.toml, uv.lock, poetry.lock, and pdm.lock are regenerated natively without executing the package manager. For Pipfile, Pipfile.lock is regenerated natively by consulting the project's package index over the network. Not safe to use as a precondition: invokes the package manager or the network and publishes per-project state shared with other dependency recipes.

Data tables:

• org.openrewrite.python.table.PythonLockRegenerationFailures: Lock files that could not be regenerated after a dependency edit, and why.

org.openrewrite.python.search.DependencyInsight

• Python dependency insight
• Find direct and transitive Python dependencies matching a package name pattern. Results include dependencies that either directly match or transitively include a matching dependency.

Data tables:

• org.openrewrite.python.table.PythonDependenciesInUse: Direct and transitive dependencies in use in Python projects.

rewrite-xml

org.openrewrite.xml.style.AutodetectDebug

• XML style Auto-detection debug
• Runs XML Autodetect and records the results in data tables and search markers. A debugging tool for figuring out why XML documents get styled the way they do.

Data tables:

• org.openrewrite.xml.table.XmlStyleReport: Records style information about XML documents. Used for debugging style auto-detection issues.

org.openrewrite.recipe

rewrite-all

org.openrewrite.FindCallGraph

• Find call graph
• Produces a data table where each row represents a method call.

Data tables:

• org.openrewrite.table.CallGraph: Records method callers and the methods they invoke.
• org.openrewrite.table.FactoryEdges: Construction edges where the caller's declared return type is assignable from the constructed class (the caller semantically produces an instance of the target type).
• org.openrewrite.table.LowConfidenceFiles: Source files where call-graph construction skipped an edge because the underlying LST had a null type. Used as a confidence signal during test selection: any row for a file means that file's outbound edges may be undercounted.

org.openrewrite.FindDuplicateSourceFiles

• Find duplicate source files
• Record the presence of LSTs with duplicate paths, indicating that the same file was parsed more than once.

Data tables:

• org.openrewrite.table.DuplicateSourceFiles: A list of source files that occur more than once in an LST.

org.openrewrite.LanguageComposition

• Language composition report
• Counts the number of lines of the various kinds of source code and data formats parsed by OpenRewrite. Comments are not included in line counts. This recipe emits its results as two data tables, making no changes to any source file. One data table is per-file, the other is per-repository.

Data tables:

• org.openrewrite.table.LanguageCompositionPerRepository: Counts the number of files and lines of source code in the various formats OpenRewrite knows how to parse.
• org.openrewrite.table.LanguageCompositionPerFolder: A list of folders and the language composition and line counts of their contents.
• org.openrewrite.table.LanguageCompositionPerFile: A list of individual files and their language composition.

rewrite-android

org.openrewrite.android.MigrateToAndroidGradlePlugin_7_2

• Migrate to Android Gradle Plugin 7.2
• Recipes to migrate to Android Gradle Plugin version 7.2.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_7_3

• Migrate to Android Gradle Plugin 7.3
• Recipes to migrate to Android Gradle Plugin version 7.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_7_4

• Migrate to Android Gradle Plugin 7.4
• Recipes to migrate to Android Gradle Plugin version 7.4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_0

• Migrate to Android Gradle Plugin 8.0
• Recipes to migrate to Android Gradle Plugin version 8.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_1

• Migrate to Android Gradle Plugin 8.1
• Recipes to migrate to Android Gradle Plugin version 8.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_10

• Migrate to Android Gradle Plugin 8.10
• Recipes to migrate to Android Gradle Plugin version 8.10.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_11

• Migrate to Android Gradle Plugin 8.11
• Recipes to migrate to Android Gradle Plugin version 8.11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_12

• Migrate to Android Gradle Plugin 8.12
• Recipes to migrate to Android Gradle Plugin version 8.12.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_13

• Migrate to Android Gradle Plugin 8.13
• Recipes to migrate to Android Gradle Plugin version 8.13.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_2

• Migrate to Android Gradle Plugin 8.2
• Recipes to migrate to Android Gradle Plugin version 8.2.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_3

• Migrate to Android Gradle Plugin 8.3
• Recipes to migrate to Android Gradle Plugin version 8.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_4

• Migrate to Android Gradle Plugin 8.4
• Recipes to migrate to Android Gradle Plugin version 8.4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_5

• Migrate to Android Gradle Plugin 8.5
• Recipes to migrate to Android Gradle Plugin version 8.5.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_6

• Migrate to Android Gradle Plugin 8.6
• Recipes to migrate to Android Gradle Plugin version 8.6.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_7

• Migrate to Android Gradle Plugin 8.7
• Recipes to migrate to Android Gradle Plugin version 8.7.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_8

• Migrate to Android Gradle Plugin 8.8
• Recipes to migrate to Android Gradle Plugin version 8.8.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_8_9

• Migrate to Android Gradle Plugin 8.9
• Recipes to migrate to Android Gradle Plugin version 8.9.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_9_0

• Migrate to Android Gradle Plugin 9.0
• Recipes to migrate to Android Gradle Plugin version 9.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_9_1

• Migrate to Android Gradle Plugin 9.1
• Recipes to migrate to Android Gradle Plugin version 9.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.MigrateToAndroidGradlePlugin_9_2

• Migrate to Android Gradle Plugin 9.2
• Recipes to migrate to Android Gradle Plugin version 9.2.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.UpgradeAndroidGradlePluginVersion

• Upgrade Android Gradle Plugin (AGP) version
• Upgrade Android Gradle Plugin (AGP) version and update the Gradle Wrapper version. Compatible versions are published in the AGP release notes.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.UpgradeToAndroidSDK33

• Upgrade to Android SDK 33
• Recipes to upgrade to Android SDK version 33.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.UpgradeToAndroidSDK34

• Upgrade to Android SDK 34
• Recipes to upgrade to Android SDK version 34.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.UpgradeToAndroidSDK35

• Upgrade to Android SDK 35
• Recipes to upgrade to Android SDK version 35.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.android.UpgradeToAndroidSDK36

• Upgrade to Android SDK 36
• Recipes to upgrade to Android SDK version 36.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-compiled-analysis

io.moderne.compiled.verification.ChangeListMethodAndVerify

• Change List#add to List#plus and verify
• We know this won't compile.

Data tables:

• io.moderne.compiled.table.ABITraces: ASM trace of the ABI of types needed to perform compile verification.
• io.moderne.compiled.table.CompilationFailures: Elements that no longer compile after a preceding recipe made changes to the file.

io.moderne.compiled.verification.VerifyCompilation

• Verify compilation of changes made earlier in the same run
• Recompile the source files that earlier recipes in this same recipe run changed, and mark the elements that no longer compile. This recipe examines only files carrying a RecipesThatMadeChanges marker, so running it on its own reports nothing at all, no matter how badly broken the code in the repository is. It is a verification step for a migration, not a standalone compiler. Compose it after the recipe whose output you want to verify: yaml type: specs.openrewrite.org/v1beta/recipe name: com.yourorg.MigrateAndVerify displayName: Migrate and verify description: Rename a method and verify that the result still compiles. recipeList: - org.openrewrite.java.ChangeMethodName: methodPattern: java.util.List add(..) newMethodName: plus - io.moderne.compiled.verification.VerifyCompilation Failures appear as inline warnings on the offending elements, so a run that produces no warnings either verified everything successfully or had nothing to verify.

Data tables:

• io.moderne.compiled.table.ABITraces: ASM trace of the ABI of types needed to perform compile verification.
• io.moderne.compiled.table.CompilationFailures: Elements that no longer compile after a preceding recipe made changes to the file.

rewrite-dotnet

org.openrewrite.dotnet.UpgradeAssistantAnalyze

• Analyze a .NET project using upgrade-assistant
• Run upgrade-assistant analyze across a repository to analyze changes required to upgrade projects to a newer version of .NET. This recipe will generate an org.openrewrite.dotnet.UpgradeAssistantAnalysis data table containing the report details.

Data tables:

• org.openrewrite.dotnet.UpgradeAssistantAnalysis: .NET project upgrade analysis report generated by upgrade-assistant.

rewrite-github-actions

org.openrewrite.github.FindGitHubActionSecretReferences

• Find GitHub action secret references
• Help identify and inventory your GitHub secrets that are being used in GitHub actions.

Data tables:

• org.openrewrite.table.TextMatches: Lines matching simple text search.

rewrite-java-dependencies

org.openrewrite.java.dependencies.DependencyInsight

• Dependency insight for Gradle and Maven
• Finds dependencies, including transitive dependencies, in both Gradle and Maven projects. Matches within all Gradle dependency configurations and Maven scopes.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.

org.openrewrite.java.dependencies.DependencyList

• Dependency report
• Emits a data table detailing all Gradle and Maven dependencies. This recipe makes no changes to any source file.

Data tables:

• org.openrewrite.java.dependencies.table.DependencyListReport: Lists all Gradle and Maven dependencies
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.dependencies.DependencyResolutionDiagnostic

• Dependency resolution diagnostic
• Recipes which manipulate dependencies must be able to successfully access the artifact repositories and resolve dependencies from them. This recipe produces two data tables used to understand the state of dependency resolution. The Repository accessibility report lists all the artifact repositories known to the project and whether respond to network access. The network access is attempted while the recipe is run and so is representative of current conditions. The Gradle dependency configuration errors lists all the dependency configurations that failed to resolve one or more dependencies when the project was parsed. This is representative of conditions at the time the LST was parsed.

Data tables:

• org.openrewrite.java.dependencies.table.RepositoryAccessibilityReport: Listing of all dependency repositories and whether they are accessible.
• org.openrewrite.java.dependencies.table.GradleDependencyConfigurationErrors: Records Gradle dependency configurations which failed to resolve during parsing. Partial success/failure is common, a failure in this list does not mean that every dependency failed to resolve.

org.openrewrite.java.dependencies.FindRepositoryOrder

• Maven repository order
• Determine the order in which dependencies will be resolved for each pom.xml or build.gradle based on its defined repositories and effective settings.

Data tables:

• org.openrewrite.maven.table.MavenRepositoryOrder: The order in which dependencies will be resolved for each pom.xml based on its defined repositories and effective settings.xml.

org.openrewrite.java.dependencies.RelocatedDependencyCheck

• Find relocated dependencies
• Find Maven and Gradle dependencies and Maven plugins that have relocated to a new groupId or artifactId. Relocation information comes from the oga-maven-plugin maintained by Jonathan Lermitage, Filipe Roque and others. This recipe makes no changes to any source file by default. Add changeDependencies=true to change dependencies, but note that you might need to run additional recipes to update imports and adopt other breaking changes.

Data tables:

• org.openrewrite.java.dependencies.table.RelocatedDependencyReport: A list of dependencies in use that have relocated.

org.openrewrite.java.dependencies.search.FindDuplicateClasses

• Find duplicate classes on the classpath
• Detects classes that appear in multiple dependencies on the classpath. This is similar to what the Maven duplicate-finder-maven-plugin does. Duplicate classes can cause runtime issues when different versions of the same class are loaded.

Data tables:

• org.openrewrite.java.dependencies.table.DuplicateClassesReport: Lists classes that appear in multiple dependencies on the classpath

org.openrewrite.java.dependencies.search.FindMinimumDependencyVersion

• Find the oldest matching dependency version in use
• The oldest dependency version in use is the lowest dependency version in use in any source set of any subproject of a repository. It is possible that, for example, the main source set of a project uses Jackson 2.11, but a test source set uses Jackson 2.16. In this case, the oldest Jackson version in use is Java 2.11.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.

org.openrewrite.java.dependencies.search.FindMinimumJUnitVersion

• Find minimum JUnit version
• A recipe to find the minimum version of JUnit dependencies. This recipe is designed to return the minimum version of JUnit in a project. It will search for JUnit 4 and JUnit 5 dependencies in the project. If both versions are found, it will return the minimum version of JUnit 4. If a minimumVersion is provided, the recipe will search to see if the minimum version of JUnit used by the project is no lower than the minimumVersion. For example: if the minimumVersion is 4, and the project has JUnit 4.12 and JUnit 5.7, the recipe will return JUnit 4.12. If the project has only JUnit 5.7, the recipe will return JUnit 5.7. Another example: if the minimumVersion is 5, and the project has JUnit 4.12 and JUnit 5.7, the recipe will not return any results.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.

rewrite-java-security

org.openrewrite.csharp.dependencies.DependencyInsight

• Dependency insight for C#
• Finds dependencies in *.csproj and packages.config.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.

org.openrewrite.csharp.dependencies.DependencyVulnerabilityCheck

• Find and fix vulnerable Nuget dependencies
• This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from the GitHub Security Advisory Database, which aggregates vulnerability data from several public databases, including the National Vulnerability Database maintained by the United States government. Dependencies following Semantic Versioning will see their patch version updated where applicable. Last updated: 2026-08-24T1108.

Data tables:

• org.openrewrite.csharp.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.

org.openrewrite.csharp.dependencies.FindEndOfLifeDependencies

• Find end-of-life NuGet dependencies
• Find NuGet packages whose upstream release is end-of-life or scheduled for end-of-life soon, using a snapshot of endoflife.date. Direct package references are marked in source; all matches (direct and transitive) are reported in the data table.

Data tables:

• org.openrewrite.csharp.dependencies.table.EndOfLifeDependencyReport: NuGet packages whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.

org.openrewrite.dependencies.endoflife.FindEndOfLifeDependenciesDefault

• Find end-of-life dependencies (defaults)
• Flags Maven, Gradle, npm, and NuGet dependencies whose upstream release is end-of-life or reaches end-of-life within the next 180 days, using the bundled endoflife.date snapshot. Aggregates the per-ecosystem find-end-of-life recipes with their default settings.

Data tables:

• org.openrewrite.java.dependencies.endoflife.table.EndOfLifeDependencyReport: Maven and Gradle dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.csharp.dependencies.table.EndOfLifeDependencyReport: NuGet packages whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.node.dependencies.table.EndOfLifeDependencyReport: npm dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.

org.openrewrite.golang.dependencies.DependencyVulnerabilityCheck

• Find and fix vulnerable Go dependencies
• This software composition analysis (SCA) tool detects and upgrades Go module dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades go.mod to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from the GitHub Security Advisory Database, which aggregates vulnerability data from several public databases, including the National Vulnerability Database maintained by the United States government. When a go.sum file is present it is regenerated to match the upgraded go.mod by running go mod download, which requires the go toolchain to be installed. If the toolchain is unavailable the go.mod change is still applied and the go.sum is flagged so it can be brought back in sync with go mod tidy. Because the module graph is not re-resolved, upgrades that introduce new indirect requirements may still need a follow-up go mod tidy. ## Customizing Vulnerability Data This recipe can be customized by extending DependencyVulnerabilityCheckBase and overriding the vulnerability data sources: - baselineVulnerabilities(ExecutionContext ctx): Provides the default set of known vulnerabilities. The base implementation loads vulnerability data from the GitHub Security Advisory Database CSV file using ResourceUtils.parseResourceAsCsv(). Override this method to replace the entire vulnerability dataset with your own curated list. - supplementalVulnerabilities(ExecutionContext ctx): Allows adding custom vulnerability data beyond the baseline. The base implementation returns an empty list. Override this method to add organization-specific vulnerabilities, internal security advisories, or vulnerabilities from additional sources while retaining the baseline GitHub Advisory Database. Both methods return List<Vulnerability> objects. Vulnerability data can be loaded from CSV files using ResourceUtils.parseResourceAsCsv(path, Vulnerability.class, consumer) or constructed programmatically.

Data tables:

• org.openrewrite.golang.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.

org.openrewrite.golang.security.GoSecurityBestPractices

• Go security best practices
• Locates common security vulnerabilities in Go code, mirroring the checks performed by gosec.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.golang.security.search.FindCommandInjection

• Find command execution vectors in Go
• Finds Go calls into os/exec (Command, CommandContext). When any part of the command or its arguments is derived from user input, these calls can allow OS command injection. Review each call site to ensure the executable and its arguments are not externally controlled.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.golang.security.search.FindInsecureRandom

• Find use of insecure random number generation in Go
• Finds Go calls into math/rand and math/rand/v2. These generators are not cryptographically secure and must not be used to produce secrets, tokens, nonces, salts, or any other security-sensitive value. Use crypto/rand instead.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.golang.security.search.FindSqlInjection

• Find SQL injection vectors in Go
• Finds query-executing methods on database/sql types (DB, Tx, Conn, Stmt). When a query string is built by concatenating user input rather than using bind parameters (? / $1 placeholders), these calls can allow SQL injection. Review each call site to ensure queries are parameterized.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.golang.security.search.FindWeakCryptoAlgorithm

• Find use of weak cryptographic algorithms in Go
• Finds Go calls into crypto/md5, crypto/sha1, crypto/des, and crypto/rc4. These algorithms are cryptographically broken and should not be used for security-sensitive purposes such as hashing passwords, generating signatures, or encrypting data. Prefer SHA-256 or stronger (crypto/sha256, crypto/sha512) and AES (crypto/aes).

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.dependencies.AddExplicitTransitiveDependencies

• Add explicit transitive dependencies
• Detects when Java source code or configuration files reference types from transitive Maven dependencies and promotes those transitive dependencies to explicit direct dependencies in the pom.xml. This ensures the build is resilient against changes in transitive dependency trees of upstream libraries.

Data tables:

• org.openrewrite.java.dependencies.table.PromotedTransitiveDependencies: Transitive dependencies that were promoted to direct dependencies because source code references types from them.

org.openrewrite.java.dependencies.DependencyLicenseCheck

• Find licenses in use in third-party dependencies
• Locates and reports on all licenses in use.

Data tables:

• org.openrewrite.java.dependencies.table.LicenseReport: Contains a license report of third-party dependencies.

org.openrewrite.java.dependencies.DependencyVulnerabilityCheck

• Find and fix vulnerable Maven/Gradle dependencies
• This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from the GitHub Security Advisory Database, which aggregates vulnerability data from several public databases, including the National Vulnerability Database maintained by the United States government. Upgrades dependencies versioned according to Semantic Versioning. ## Customizing Vulnerability Data This recipe can be customized by extending DependencyVulnerabilityCheckBase and overriding the vulnerability data sources: - baselineVulnerabilities(ExecutionContext ctx): Provides the default set of known vulnerabilities. The base implementation loads vulnerability data from the GitHub Security Advisory Database CSV file using ResourceUtils.parseResourceAsCsv(). Override this method to replace the entire vulnerability dataset with your own curated list. - supplementalVulnerabilities(ExecutionContext ctx): Allows adding custom vulnerability data beyond the baseline. The base implementation returns an empty list. Override this method to add organization-specific vulnerabilities, internal security advisories, or vulnerabilities from additional sources while retaining the baseline GitHub Advisory Database. Both methods return List<Vulnerability> objects. Vulnerability data can be loaded from CSV files using ResourceUtils.parseResourceAsCsv(path, Vulnerability.class, consumer) or constructed programmatically. To customize, extend DependencyVulnerabilityCheckBase and override one or both methods depending on your needs. For example, override supplementalVulnerabilities() to add custom CVEs while keeping the standard vulnerability database, or override baselineVulnerabilities() to use an entirely different vulnerability data source. Last updated: 2026-08-24T1108.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• org.openrewrite.java.dependencies.table.DependencyOriginsReport: A report that maps dependencies to their originating root node represented as dependency graph. The information can be used to understand which direct dependencies are responsible for bringing in specific transitive dependencies.

org.openrewrite.java.dependencies.RemoveUnusedDependencies

• Remove unused dependencies
• Scans through source code collecting references to types and methods, removing any dependencies that are not used from Maven or Gradle build files. This is best effort and not guaranteed to work well in all cases; false positives are still possible. This recipe takes reflective access into account: - When reflective access to a class is made unambiguously via a string literal, such as: Class.forName("java.util.List") that is counted correctly. - When reflective access to a class is made ambiguously via anything other than a string literal no dependencies will be removed. This recipe takes transitive dependencies into account: - When a direct dependency is not used but a transitive dependency it brings in is in use the direct dependency is not removed.

Data tables:

• org.openrewrite.java.dependencies.table.DependencyUsageEvidence: Evidence showing that a dependency is in use in the project.

org.openrewrite.java.dependencies.endoflife.FindEndOfLifeDependencies

• Find end-of-life dependencies
• Find Maven and Gradle dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, using a snapshot of endoflife.date. Direct dependencies are marked in source; all matches (direct and transitive) are reported in the data table.

Data tables:

• org.openrewrite.java.dependencies.endoflife.table.EndOfLifeDependencyReport: Maven and Gradle dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.

org.openrewrite.java.security.Owasp2025A01

• Remediate OWASP A01:2025 Broken access control
• OWASP A01:2025 describes failures related to broken access control.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.

org.openrewrite.java.security.Owasp2025A03

• Remediate OWASP A03:2025 Software supply chain failures
• OWASP A03:2025 describes failures related to the software supply chain, including vulnerable and outdated components. Expanded from A06:2021 Vulnerable and Outdated Components.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• org.openrewrite.java.dependencies.table.DependencyOriginsReport: A report that maps dependencies to their originating root node represented as dependency graph. The information can be used to understand which direct dependencies are responsible for bringing in specific transitive dependencies.
• org.openrewrite.java.dependencies.endoflife.table.EndOfLifeDependencyReport: Maven and Gradle dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.csharp.dependencies.table.EndOfLifeDependencyReport: NuGet packages whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.node.dependencies.table.EndOfLifeDependencyReport: npm dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.Owasp2025A04

• Remediate OWASP A04:2025 Cryptographic failures
• OWASP A04:2025 describes failures related to cryptography (or lack thereof), which often lead to exposure of sensitive data. Previously A02:2021.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.Owasp2025A05

• Remediate OWASP A05:2025 Injection
• OWASP A05:2025 describes failures related to user-supplied data being used to influence program state to operate outside of its intended bounds. Previously A03:2021.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.java.security.Owasp2025A07

• Remediate OWASP A07:2025 Identification and authentication failures
• OWASP A07:2025 describes failures related to identification and authentication, including weak credential management, missing brute force protections, session fixation, hardcoded credentials, insecure "remember me", and missing multi-factor authentication. Same position as A07:2021 (no prior aggregator existed).

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.java.security.Owasp2025A08

• Remediate OWASP A08:2025 Software or data integrity failures
• OWASP A08:2025 describes failures to verify the integrity of software, code, and data artifacts across a trust boundary, including deserialization of untrusted data. Same position as A08:2021 Software and data integrity failures; the broader supply chain concerns that shared that category moved to A03:2025.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.OwaspA01

• Remediate OWASP A01:2021 Broken access control
• OWASP A01:2021 describes failures related to broken access control.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.

org.openrewrite.java.security.OwaspA02

• Remediate OWASP A02:2021 Cryptographic failures
• OWASP A02:2021 describes failures related to cryptography (or lack thereof), which often lead to exposure of sensitive data. This recipe seeks to remediate these vulnerabilities.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.OwaspA06

• Remediate OWASP A06:2021 Vulnerable and outdated components
• OWASP A06:2021 describes failures related to vulnerable and outdated components.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• org.openrewrite.java.dependencies.table.DependencyOriginsReport: A report that maps dependencies to their originating root node represented as dependency graph. The information can be used to understand which direct dependencies are responsible for bringing in specific transitive dependencies.

org.openrewrite.java.security.OwaspA08

• Remediate OWASP A08:2021 Software and data integrity failures
• OWASP A08:2021 software and data integrity failures.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.OwaspTopTen

• Remediate vulnerabilities from the OWASP Top Ten
• OWASP publishes a list of the most impactful common security vulnerabilities. These recipes identify and remediate vulnerabilities from the OWASP Top Ten.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• org.openrewrite.java.dependencies.table.DependencyOriginsReport: A report that maps dependencies to their originating root node represented as dependency graph. The information can be used to understand which direct dependencies are responsible for bringing in specific transitive dependencies.

org.openrewrite.java.security.OwaspTopTen2025

• Remediate vulnerabilities from the OWASP Top Ten 2025
• OWASP publishes a list of the most impactful common security vulnerabilities. These recipes identify and remediate vulnerabilities from the OWASP Top Ten 2025.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.
• org.openrewrite.java.dependencies.table.DependencyOriginsReport: A report that maps dependencies to their originating root node represented as dependency graph. The information can be used to understand which direct dependencies are responsible for bringing in specific transitive dependencies.
• org.openrewrite.java.dependencies.endoflife.table.EndOfLifeDependencyReport: Maven and Gradle dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.csharp.dependencies.table.EndOfLifeDependencyReport: NuGet packages whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.node.dependencies.table.EndOfLifeDependencyReport: npm dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.
• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.java.security.search.FindExpressionLanguageInjection

• Find Expression Language injection vectors
• Finds calls to Expression Language (EL) evaluation methods which, when the expression is built from user input, can allow arbitrary code execution. Use parameterized expressions or input validation instead.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindHardcodedAuthenticationCredentials

• Find hardcoded authentication credentials
• Finds hardcoded passwords flowing into Spring Security user builders: InMemoryUserDetailsManagerConfigurer (inMemoryAuthentication().withUser(...).password(...)) and the User.UserBuilder.password(...) API. Uses taint analysis so credentials assigned to a variable, field, or constant before being passed to .password(...) are also detected.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.

org.openrewrite.java.security.search.FindHttpResponseSplitting

• Find HTTP response splitting vectors
• Finds calls to HttpServletResponse.addHeader(), setHeader(), and addCookie() which, when header values are derived from user input without CRLF sanitization, can allow HTTP response splitting attacks. Full taint-based detection requires rewrite-program-analysis; this recipe identifies the sink call sites for manual review.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindJacksonDefaultTypeMapping

• Find Jackson default type mapping enablement
• ObjectMapper#enableTypeMapping(..) can lead to vulnerable deserialization.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindMissingSpringAuthorization

• Find Spring MVC handlers missing authorization
• Flags Spring MVC (and WebFlux) controller methods reachable to anonymous users — either matched by permitAll() in a SecurityFilterChain / SecurityWebFilterChain bean (or in a legacy WebSecurityConfigurerAdapter.configure(HttpSecurity) override) or with no matching rule at all — and which do not carry an explicit authorization annotation (@PreAuthorize, @PostAuthorize, @Secured, @RolesAllowed, @PermitAll, @DenyAll), including annotations inherited from a superclass or overridden parent method. Security rules are read from both the Java fluent API (requestMatchers(...).permitAll()) and the Kotlin DSL (authorize("/path", permitAll)). Detector only; does not modify code.

Data tables:

• org.openrewrite.java.security.table.MissingAuthorization: Spring MVC handler methods reachable to anonymous users without an explicit authorization annotation.

org.openrewrite.java.security.search.FindProcessControl

• Find process control vectors
• Finds calls to System.loadLibrary(), System.load(), and Runtime.load() which, when the library path or name is derived from user input, can allow an attacker to load arbitrary native code. Ensure library names are not externally controlled.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindResourceInjection

• Find resource injection vectors
• Detects resource injection vulnerabilities where user-controlled input flows to resource access operations — file paths, JNDI lookups, class loading, and native library loading. Uses taint analysis from rewrite-program-analysis for source-to-sink tracking with sanitizer support, plus structural detection as fallback.

Data tables:

• org.openrewrite.analysis.java.taint.table.TaintFlowTable: Records taint flows from sources to sinks with their taint types.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindScriptEngineInjection

• Find script engine code injection vectors
• Finds calls to ScriptEngine.eval() which can execute arbitrary code if the script string is influenced by user input. Consider sandboxing or removing dynamic script evaluation.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindSensitiveApiEndpoints

• Find sensitive API endpoints
• Find data models exposed by REST APIs that contain sensitive information like PII and secrets.

Data tables:

• org.openrewrite.java.security.table.SensitiveApiEndpoints: The API endpoints that expose sensitive data.

org.openrewrite.java.security.search.FindUnsafeReflection

• Find unsafe reflection vectors
• Finds calls to Class.forName() which, when the class name is derived from user input, can allow an attacker to instantiate arbitrary classes. Review these call sites to ensure the class name is not externally controlled.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.security.search.FindXPathInjection

• Find XPath injection vectors
• Finds calls to XPath.evaluate() and XPath.compile() which, when the expression is built from user input, can allow XPath injection attacks. Use parameterized XPath expressions or input validation instead.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.node.dependencies.FindEndOfLifeDependencies

• Find end-of-life npm dependencies
• Find npm dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, using a snapshot of endoflife.date. Direct dependencies declared in package.json are marked in source; all matches (direct and transitive) are reported in the data table.

Data tables:

• org.openrewrite.node.dependencies.table.EndOfLifeDependencyReport: npm dependencies whose upstream release is end-of-life or scheduled for end-of-life soon, as reported by https://endoflife.date.

org.openrewrite.python.dependencies.DependencyVulnerabilityCheck

• Find and fix vulnerable PyPI dependencies
• This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from the GitHub Security Advisory Database, which aggregates vulnerability data from several public databases, including the National Vulnerability Database maintained by the United States government. Dependencies following Semantic Versioning will see their patch version updated where applicable. ## Customizing Vulnerability Data This recipe can be customized by extending DependencyVulnerabilityCheckBase and overriding the vulnerability data sources: - baselineVulnerabilities(ExecutionContext ctx): Provides the default set of known vulnerabilities. The base implementation loads vulnerability data from the GitHub Security Advisory Database CSV file using ResourceUtils.parseResourceAsCsv(). Override this method to replace the entire vulnerability dataset with your own curated list. - supplementalVulnerabilities(ExecutionContext ctx): Allows adding custom vulnerability data beyond the baseline. The base implementation returns an empty list. Override this method to add organization-specific vulnerabilities, internal security advisories, or vulnerabilities from additional sources while retaining the baseline GitHub Advisory Database. Both methods return List<Vulnerability> objects. Vulnerability data can be loaded from CSV files using ResourceUtils.parseResourceAsCsv(path, Vulnerability.class, consumer) or constructed programmatically. To customize, extend DependencyVulnerabilityCheckBase and override one or both methods depending on your needs. For example, override supplementalVulnerabilities() to add custom CVEs while keeping the standard vulnerability database, or override baselineVulnerabilities() to use an entirely different vulnerability data source.

Data tables:

• org.openrewrite.python.dependencies.table.VulnerabilityReport: A vulnerability report that includes detailed information about the affected artifact and the corresponding CVEs.

org.openrewrite.text.FindHardcodedLoopbackAddresses

• Find hard-coded loopback IPv4 addresses
• Locates mentions of hard-coded IPv4 addresses from the loopback IP range. The loopback IP range includes 127.0.0.0 to 127.255.255.255. This detects the entire localhost/loopback subnet range, not just the commonly used 127.0.0.1.

Data tables:

• org.openrewrite.text.table.HardcodedPrivateIPAddresses: This table lists locations of hardcoded private IPv4 addresses and their value found in source files.

org.openrewrite.text.FindHardcodedPrivateIPAddresses

• Find hard-coded private IPv4 addresses
• Locates mentions of hard-coded IPv4 addresses from private IP ranges. Private IP ranges include: * 192.168.0.0 to 192.168.255.255 * 10.0.0.0 to 10.255.255.255 * 172.16.0.0 to 172.31.255.255 It is not detecting the localhost subnet 127.0.0.0 to 127.255.255.255.

Data tables:

• org.openrewrite.text.table.HardcodedPrivateIPAddresses: This table lists locations of hardcoded private IPv4 addresses and their value found in source files.

rewrite-jenkins

org.openrewrite.jenkins.ModernizePlugin

• Modernize a Jenkins plugin to the latest recommended versions
• This recipe is intended to change over time to reflect the recommended tooling and recommended Jenkins baseline.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.jenkins.ModernizePluginForJava8

• Modernize a Jenkins plugin to the latest versions supported by Java 8
• This recipe is intended to break down the modernization of very old plugins into distinct steps. It allows modernizing all tooling up to the last versions that supported Java 8. This can then be followed by another recipe that makes the jump to Java 11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-kubernetes

io.moderne.kubernetes.sylva.migrate.dasschiff.FindBgpPeeringMigrationBlockers

• Find what blocks a Das Schiff BGPPeering from moving to the Sylva network connector API
• Report what a human has to decide before a Das Schiff BGPPeering can move to the network-connector.sylvaproject.org group. Nothing is rewritten: the legacy spec.export is a reject-by-default prefix filter and the intent one is accept-by-default BGP communities, so a peering moved as it stands would advertise the whole VRF table.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.BgpPeerings: Deutsche Telekom network.t-caas.telekom.com BGPPeering resources, and what each one needs decided before it can be written against the network-connector.sylvaproject.org BGPPeering that shares its name.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindDasSchiffMigrationWork

• Find Das Schiff resources that have to move to Sylva
• Inventory every Das Schiff resource the Sylva intent group replaces and report, per kind, whether it moves automatically or what has to be decided first. All eight legacy kinds are marked, the three the operator generates included, so a kind that goes unmentioned is one this catalogue does not know about. A repository partway through the move also reports where the intent resources it already holds no longer say what the legacy ones do. Reports only; nothing is rewritten.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.LowLevelNetworkConfigs: Deutsche Telekom network.t-caas.telekom.com resources that the network-connector.sylvaproject.org intent group replaces, and whether each one can be moved mechanically.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.MirrorConfigs: Deutsche Telekom MirrorTarget and MirrorSelector resources that the network-connector.sylvaproject.org Collector and TrafficMirror replace, and whether each one can be moved mechanically.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.BgpPeerings: Deutsche Telekom network.t-caas.telekom.com BGPPeering resources, and what each one needs decided before it can be written against the network-connector.sylvaproject.org BGPPeering that shares its name.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.IntentDrift: Where the network-connector.sylvaproject.org resources in a repository do not say what the network.t-caas.telekom.com resources beside them said.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.ExportRanges: Every spec.export range of a Deutsche Telekom VRFRouteConfiguration, and whether it is classified as the load balancer pool or the egress NAT pool the network-connector.sylvaproject.org intent group needs it to be.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.NetworkOperatorConfigMaps: One row per data key of every ConfigMap that configures Deutsche Telekom's das-schiff-network-operator, describing where it lives and what shape it is in. A ConfigMap that declares no keys still gets a row, so that the inventory is of ConfigMaps and not only of keys.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindIntentMigrationDrift

• Find drift between Das Schiff and Sylva intent network resources
• Compare the network.t-caas.telekom.com resources in a repository against the network-connector.sylvaproject.org resources meant to replace them, and report every field the two no longer agree on. They are paired by VRF name and VLAN id, so a hand written translation is checked as readily as a generated one.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.IntentDrift: Where the network-connector.sylvaproject.org resources in a repository do not say what the network.t-caas.telekom.com resources beside them said.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindLowLevelNetworkConfig

• Find VRFRouteConfiguration and Layer2NetworkConfiguration to migrate
• Find the Das Schiff VRFRouteConfiguration and Layer2NetworkConfiguration resources the Sylva intent group replaces, and report for each whether it moves automatically or why it has to be moved by hand. Resources that do move also report the fields the intent group derives rather than stores, which are the ones worth re-reading in review.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.LowLevelNetworkConfigs: Deutsche Telekom network.t-caas.telekom.com resources that the network-connector.sylvaproject.org intent group replaces, and whether each one can be moved mechanically.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindMirrorConfig

• Find Das Schiff traffic mirror configuration
• Find the Das Schiff MirrorTarget and MirrorSelector resources the Sylva Collector and TrafficMirror replace, and report for each whether it moves automatically or why it has to be moved by hand. Reports only; nothing is rewritten.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.MirrorConfigs: Deutsche Telekom MirrorTarget and MirrorSelector resources that the network-connector.sylvaproject.org Collector and TrafficMirror replace, and whether each one can be moved mechanically.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindNetworkOperatorConfigMap

• Find Das Schiff network operator ConfigMaps
• Inventory the ConfigMaps that configure Das Schiff's network operator, reporting for each data key how the value is written and how large it is. Each key is a whole embedded document the operator hands to its node agents as a file, not a setting. Nothing here reads those documents, so the report holds for any version of them.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.NetworkOperatorConfigMaps: One row per data key of every ConfigMap that configures Deutsche Telekom's das-schiff-network-operator, describing where it lives and what shape it is in. A ConfigMap that declares no keys still gets a row, so that the inventory is of ConfigMaps and not only of keys.

io.moderne.kubernetes.sylva.migrate.dasschiff.FindUnclassifiedExportRanges

• Find unclassified Das Schiff export ranges
• Report every VRFRouteConfiguration.spec.export range that has to be classified as a load balancer pool or an egress NAT pool before an Inbound or Outbound can be generated for it. Nothing in the legacy group tells the two apart.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.ExportRanges: Every spec.export range of a Deutsche Telekom VRFRouteConfiguration, and whether it is classified as the load balancer pool or the egress NAT pool the network-connector.sylvaproject.org intent group needs it to be.

io.moderne.kubernetes.sylva.migrate.dasschiff.GenerateInboundAndOutboundFromExportRanges

• Generate Inbound and Outbound from export ranges
• Generate a Sylva Inbound or Outbound for each VRFRouteConfiguration.spec.export range the classifications option names as a load balancer pool or an egress NAT pool. Nothing in the legacy group tells the two apart, so an unclassified range is reported and left alone rather than guessed at.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.ExportRanges: Every spec.export range of a Deutsche Telekom VRFRouteConfiguration, and whether it is classified as the load balancer pool or the egress NAT pool the network-connector.sylvaproject.org intent group needs it to be.

io.moderne.kubernetes.sylva.migrate.dasschiff.MigrateLowLevelNetworkConfigToIntent

• Migrate VRFRouteConfiguration and Layer2NetworkConfiguration to Sylva
• Rewrite Das Schiff VRFRouteConfiguration and Layer2NetworkConfiguration resources into the network-connector.sylvaproject.org intent resources that replace them. Each becomes two: a VRF and a Destination, or a Network and a Layer2Attachment. Both kinds move here rather than in a recipe each, because a VRF moves whole or not at all. A resource whose meaning would change is reported rather than approximated.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.LowLevelNetworkConfigs: Deutsche Telekom network.t-caas.telekom.com resources that the network-connector.sylvaproject.org intent group replaces, and whether each one can be moved mechanically.

io.moderne.kubernetes.sylva.migrate.dasschiff.MigrateMirrorConfigToIntent

• Migrate Das Schiff traffic mirror configuration to intent resources
• Rewrite Das Schiff MirrorTarget and MirrorSelector resources into the Collector and TrafficMirror that replace them. A Collector repeats its loopback's subnet inline, so a target whose mirror VRF is not declared in the same manifest is reported rather than moved.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.MirrorConfigs: Deutsche Telekom MirrorTarget and MirrorSelector resources that the network-connector.sylvaproject.org Collector and TrafficMirror replace, and whether each one can be moved mechanically.

io.moderne.kubernetes.sylva.migrate.dasschiff.MigrateTCaasToSylvaNetworkConnector

• Migrate T-CaaS network resources to the Sylva network connector API
• Move what can be moved without a decision from Das Schiff's low level network.t-caas.telekom.com group onto the network-connector.sylvaproject.org intent group. Four of the eight legacy kinds move: VRFRouteConfiguration and Layer2NetworkConfiguration together rather than one at a time, because a VRF whose attachment stays behind stops advertising that attachment's subnet, and MirrorTarget and MirrorSelector likewise, because a selector without its collector points at nothing. BGPPeering is report-only. NodeNetworkConfig, NodeNetplanConfig and NetworkConfigRevision are operator output rather than input — the first two are named after a node and owned by it, the third by a hash of its own spec — so their absence is not a gap.

Data tables:

• io.moderne.kubernetes.sylva.migrate.dasschiff.table.LowLevelNetworkConfigs: Deutsche Telekom network.t-caas.telekom.com resources that the network-connector.sylvaproject.org intent group replaces, and whether each one can be moved mechanically.
• io.moderne.kubernetes.sylva.migrate.dasschiff.table.MirrorConfigs: Deutsche Telekom MirrorTarget and MirrorSelector resources that the network-connector.sylvaproject.org Collector and TrafficMirror replace, and whether each one can be moved mechanically.

org.openrewrite.kubernetes.clusterapi.MigrateClusterApiCoreResourceToV1beta2

• Migrate the Cluster API core group to v1beta2
• Rewrite cluster.x-k8s.io/v1beta1 resources into their v1beta2 form, fields and apiVersion together. v1beta1 has been deprecated since Cluster API v1.11 and stops being served in v1.16. A resource moves as a whole or not at all: where v1beta2 dropped a field outright, or a duration cannot be read exactly, it stays on v1beta1 and the reason is reported.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateClusterApiCoreToV1beta2

• Migrate the Cluster API core group to v1beta2
• Rewrite every cluster.x-k8s.io/v1beta1 resource Cluster API owns into its v1beta2 form, fields and apiVersion together. v1beta1 has been deprecated since Cluster API v1.11 and stops being served in v1.16. To migrate a subset, compose your own list from the per-kind recipes below.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateClusterClassToV1beta2

• Migrate ClusterClass to cluster.x-k8s.io/v1beta2
• Rewrite a ClusterClass into its v1beta2 form. Templates are named through templateRef without the template wrapper. A templateRef still carries an apiVersion, so which are safe to re-point belongs to the provider serving each kind and is reported rather than guessed.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateClusterToV1beta2

• Migrate Cluster to cluster.x-k8s.io/v1beta2
• Rewrite a Cluster into its v1beta2 form. spec.topology.class becomes spec.topology.classRef.name, and a spec.topology.rolloutAfter is reported rather than dropped.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachineDeploymentToV1beta2

• Migrate MachineDeployment to cluster.x-k8s.io/v1beta2
• Rewrite a MachineDeployment into its v1beta2 form. spec.strategy splits into rollout.strategy, deletion.order and remediation, and spec.minReadySeconds moves onto the machines it creates. spec.progressDeadlineSeconds and spec.revisionHistoryLimit are gone, so a resource setting either is reported rather than silently losing them.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachineDrainRuleToV1beta2

• Migrate MachineDrainRule to cluster.x-k8s.io/v1beta2
• Rewrite a MachineDrainRule into its v1beta2 form.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachineHealthCheckToV1beta2

• Migrate MachineHealthCheck to cluster.x-k8s.io/v1beta2
• Rewrite a MachineHealthCheck into its v1beta2 form. Its checks and remediation are regrouped, and nodeStartupTimeout becomes checks.nodeStartupTimeoutSeconds rather than moving under deletion with the other durations.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachinePoolToV1beta2

• Migrate MachinePool to cluster.x-k8s.io/v1beta2
• Rewrite a MachinePool into its v1beta2 form. spec.minReadySeconds moves onto the machines it creates, since MachinePoolSpec no longer holds it.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachineSetToV1beta2

• Migrate MachineSet to cluster.x-k8s.io/v1beta2
• Rewrite a MachineSet into its v1beta2 form. spec.minReadySeconds moves onto the machines it creates, since MachineSetSpec no longer holds it.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateMachineToV1beta2

• Migrate Machine to cluster.x-k8s.io/v1beta2
• Rewrite a Machine into its v1beta2 form. References name an API group rather than an apiVersion, and each metav1.Duration becomes whole seconds under deletion.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.clusterapi.MigrateToClusterApiV1beta2

• Migrate Cluster API resources to v1beta2
• Migrate every custom resource Cluster API owns to v1beta2. v1beta1 has been deprecated since v1.11 and stops being served in v1.16. The cluster.x-k8s.io kinds move fields and apiVersion together; addons and ipam change apiVersion only, because those kinds are the same shape under a new name. Two things are deliberately left behind. The four Kubeadm* kinds are not migrated at all: extraArgs changes from a map to a list throughout the embedded kubeadm configuration and the control plane regroups half its spec, so a bare swap is either rejected outright or accepted while the apiserver prunes what moved. And infrastructure.cluster.x-k8s.io is out of scope, because that group belongs to the providers, each of which decides for itself what v1beta2 means. Both have to be migrated by hand.

Data tables:

• org.openrewrite.kubernetes.clusterapi.table.ClusterApiV1beta2Migrations: Every cluster.x-k8s.io/v1beta1 resource considered, what moving it to v1beta2 rewrote, and why the ones left behind could not move.

org.openrewrite.kubernetes.crd.FindCustomResourcesUsingDeprecatedCrdFields

• Find custom resources using deprecated CRD fields
• Find custom resources that set a field which a CustomResourceDefinition in this repository marks deprecated, or that are on a version the CustomResourceDefinition deprecates. controller-gen copies Go doc comments verbatim into a CRD's OpenAPI schema description, so a field deprecated in Go ships its own deprecation notice inside the CRD and no per-CRD configuration is needed.

Data tables:

• org.openrewrite.kubernetes.table.DeprecatedCrdFieldUsages: Custom resources that use something a CustomResourceDefinition in this repository marks deprecated.

org.openrewrite.kubernetes.helm.ChangeChartVersion

• Change Helm chart version
• Propagate a Helm chart version across every file that restates it: the chart's own Chart.yaml, the dependencies of the charts that consume it, Flux HelmRelease resources, k0rdent ClusterTemplate, ProviderTemplate and ServiceTemplate resources, and optionally files whose name encodes the version. dependencies[].version is a range, so by default a range that the new version already satisfies is left alone rather than pinned. Chart.lock is never edited, because its digest cannot be recomputed here; it is reported instead. Files under a chart's templates directory are Go template text and are left alone. A k0rdent template's metadata.name also encodes the chart version, but a name is an identity that ClusterDeployment, Release and *TemplateChain resources point at. Renaming it here would leave those references dangling, so this recipe changes only version fields; org.openrewrite.kubernetes.k0rdent.ChangeTemplateVersion moves the name and everything that references it together.

Data tables:

• org.openrewrite.kubernetes.table.HelmChartVersionChanges: Every place a chart version was propagated to, plus the places that were deliberately left alone.

org.openrewrite.kubernetes.k0rdent.ChangeTemplateVersion

• Change k0rdent template version
• Move a k0rdent ClusterTemplate, ProviderTemplate or ServiceTemplate to a new chart version, taking its name and everything that points at that name along with it. k0rdent encodes the chart version in the template's metadata.name, so a version bump renames the resource: aws-standalone-cp-1-0-42 becomes aws-standalone-cp-1-0-43. That name is referenced from ClusterDeployment.spec.template, from services[].template on a ClusterDeployment or MultiClusterService, from Release.spec.kcm.template, spec.regional.template, spec.capi.template and spec.providers[].template, from spec.core.kcm.template, spec.core.capi.template and spec.providers[].template on a Management or Region, and from the supportedTemplates of a ClusterTemplateChain or ServiceTemplateChain. All of them move together here, along with any file whose name encodes the template name, because a rename that misses one of them leaves a reference the controller cannot resolve. A template in a file that renders through a template engine is reported and left alone, and so are its referrers: its name is whatever the engine produces, so nothing can be moved without stranding the rest. This changes the template's own spec.helm.chartSpec.version too, but not the chart it points at. Run org.openrewrite.kubernetes.helm.ChangeChartVersion alongside it to move the chart's own Chart.yaml, the charts that depend on it, and any Flux HelmRelease.

Data tables:

• org.openrewrite.kubernetes.table.TemplateNameChanges: The template resource that was renamed, every reference that moved with it, and the templates that were left alone.

org.openrewrite.kubernetes.k0rdent.MigrateDeprecatedServiceSpecFields

• Migrate deprecated k0rdent serviceSpec fields
• Move the fields k0rdent deprecated on spec.serviceSpec into the spec.serviceSpec.provider.config blob that supersedes them, on ClusterDeployment and MultiClusterService. The nine that move are syncMode, templateResourceRefs, policyRefs, driftIgnore, driftExclusions, priority, stopOnConflict, reload and continueOnError, plus createNamespace and replace on each service's helmOptions, which move into helmOptions.installOptions. reload is renamed to reloader on the way, because that is the key the state management provider unmarshals; a hand migration that keeps the old spelling produces a manifest the apiserver accepts and the controller ignores. Fields are left where they are, and reported in a data table, when the move would change what the resource does: the document renders through Helm, so what is written is not what is applied; provider.name or provider.config is already set, in which case the controller is already ignoring the deprecated fields and moving them would switch settings on; installOptions already declares a different value; or the resource is declared against k0rdent.mirantis.com/v1alpha1, whose schema has no provider field at all, so the apiserver would prune whatever was written there. The provider.name case is the subtle one. StateManagementProviderConfigFromServiceSpec folds the deprecated fields into a config blob only when neither provider.name nor provider.config is set; name it, and every deprecated field is discarded. Moving them into provider.config would hand a named provider a syncMode, priority or reloader it is not acting on today.

Data tables:

• org.openrewrite.kubernetes.table.DeprecatedServiceSpecFields: Every deprecated serviceSpec field found, where it was moved to, and for the ones that were left in place, why.

org.openrewrite.kubernetes.search.FindContainerResourceCoverage

• Find container resource coverage
• Profile the compute resources and probes every container of every workload declares. Quantities are reported both as written and normalized to millicores and bytes, and each row carries the quality of service class the kubelet would give the pod the container belongs to.

Data tables:

• org.openrewrite.kubernetes.table.ContainerProfiles: Every container of every workload, with the compute resources and probes it declares. The raw columns answer what to change; the normalized columns answer what a cluster is being asked for.

org.openrewrite.kubernetes.search.FindDanglingResourceReferences

• Find dangling Kubernetes resource references
• Find resources that refer by name to a ConfigMap, Secret, ServiceAccount, Service, PersistentVolumeClaim, Role, ClusterRole, PriorityClass or scale target that this repository declares nowhere. There is no safe automated fix for a dangling reference — the name is either a typo, a leftover, or satisfied out of band — so this only reports. Namespace is ignored when resolving, a kustomization's namePrefix and nameSuffix are replayed so that the name a cluster sees resolves as well as the one on disk, and references whose value is templated, whose target kind appears nowhere in the repository, or whose target kind has a name some template computes are all left alone.

Data tables:

• org.openrewrite.kubernetes.table.DanglingResourceReferences: References by name to a Kubernetes resource that this repository declares nowhere.

org.openrewrite.kubernetes.search.FindHarcodedIPAddresses

• Find hardcoded IP addresses
• Find hardcoded IP address anywhere in text-based files.

Data tables:

• org.openrewrite.table.TextMatches: Lines matching simple text search.

org.openrewrite.kubernetes.search.FindKubernetesResources

• Find Kubernetes resources
• An inventory of every Kubernetes resource in a repository, one row per YAML document. The pod spec path column reports where each kind keeps its containers, so the workloads this module cannot reach are counted rather than quietly skipped.

Data tables:

• org.openrewrite.kubernetes.table.KubernetesResources: Every Kubernetes resource declared in the repository, one row per YAML document.

org.openrewrite.kubernetes.search.FindKustomizeImages

• Find kustomize images
• An inventory of every image a kustomization overrides. The images block is where a repository's image pins actually live once kustomize is in play, and it is rewritten by kustomize edit set image, sed, yq and hand edits alike, so it is worth knowing where they all are.

Data tables:

• org.openrewrite.kubernetes.table.KustomizeImages: Every image a kustomization overrides, one row per entry in an images block.

org.openrewrite.kubernetes.search.FindManifestFlavors

• Find Kubernetes manifest flavors
• Classify every YAML file in a repository by what it actually is — a manifest, a Helm chart template, a kustomization, something else entirely — and by whether an edit to it would mean what it appears to mean. This is the denominator every other Kubernetes report is a fraction of.

Data tables:

• org.openrewrite.kubernetes.table.ManifestFlavors: Every YAML file in the repository, classified by what it actually is and by whether an edit to it would mean what it appears to mean. The denominator for the coverage of every other table here.

rewrite-micrometer

org.openrewrite.micrometer.dropwizard.FindDropwizardMetrics

• Find Dropwizard metrics
• Find uses of Dropwizard metrics that could be converted to a more modern metrics instrumentation library.

Data tables:

• org.openrewrite.micrometer.table.DropwizardMetricsInUse: These metrics should be converted to a more moderne metrics instrumentation library.

rewrite-micronaut

org.openrewrite.java.micronaut.Micronaut2to3Migration

• Migrate from Micronaut 2.x to 3.x
• This recipe will apply changes required for migrating from Micronaut 2 to Micronaut 3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.Micronaut3to4Migration

• Migrate from Micronaut 3.x to 4.x
• This recipe will apply changes required for migrating from Micronaut 3 to Micronaut 4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.Micronaut4to5Migration

• Migrate from Micronaut 4.x to 5.x
• This recipe will apply changes required for migrating from Micronaut 4 to Micronaut 5. Micronaut 5 raises the Java baseline to 25 and ships a number of artifact/plugin renames; see the upstream migration guide for the full list of breaking changes.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.UpdateBuildPlugins

• Add Micronaut build plugins to 4.x
• This recipe will update the shadow jar plugin to 8.x and the Micronaut build plugins to 4.x for a Gradle build.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.UpdateBuildPlugins5

• Update Micronaut Gradle build plugins to 5.x
• This recipe will update the Micronaut Gradle build plugins to 5.x and migrate the Shadow plugin from com.github.johnrengelman.shadow to com.gradleup.shadow 9.x.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.UpdateMicronautPlatformBom

• Update to Micronaut 4.x platform BOM
• This recipe will update a Gradle or Maven build to reference the Micronaut 4 platform BOM.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.UpdateMicronautSession

• Update the Micronaut Session support
• This recipe will update the Micronaut Session dependency if needed.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.micronaut.UpdateMicronautValidation

• Update to Micronaut Validation 4.x
• This recipe will add jakarta validation dependency if needed, migrate from javax.validation if needed, and update micronaut validation dependencies.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-migrate-java

org.openrewrite.java.migrate.AddLombokMapstructBinding

• Add lombok-mapstruct-binding when both MapStruct and Lombok are used
• Add the lombok-mapstruct-binding annotation processor as needed when both MapStruct and Lombok are used.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.AddLombokMapstructBindingMavenDependencyOnly

• Add lombok-mapstruct-binding dependency for Maven when both MapStruct and Lombok are used
• Add the lombok-mapstruct-binding when both MapStruct and Lombok are used, and the dependency does not already exist. Only to be called from org.openrewrite.java.migrate.AddLombokMapstructBinding to reduce redundant checks.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.EnableLombokAnnotationProcessor

• Enable Lombok annotation processor
• With Java 23 the encapsulation of JDK internals made it necessary to configure annotation processors like Lombok explicitly. The change is valid for older versions as well.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.Java8toJava11

• Migrate to Java 11
• This recipe will apply changes commonly needed when upgrading to Java 11. Specifically, for those applications that are built on Java 8, this recipe will update and add dependencies on J2EE libraries that are no longer directly bundled with the JDK. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 11 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.JavaBestPractices

• Java best practices
• Applies opinionated best practices for Java projects targeting Java 25. This recipe includes the full Java 25 upgrade chain plus additional improvements to code style, API usage, and third-party dependency reduction that go beyond what the version migration recipes apply.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeKotlinForJava25

• Upgrade Kotlin to 2.3 for Java 25 compatibility
• Only Kotlin 2.3 and later can target Java 25 bytecode, so modules on an older Kotlin are otherwise capped at Java 24. This recipe upgrades modules that compile Kotlin (i.e. contain .kt source files) and are already on Kotlin 2.0, 2.1, or 2.2 up to the latest Kotlin 2.3, so they can subsequently be migrated to Java 25. Modules on Kotlin 1.x are left untouched, as crossing the K2 compiler default introduced in Kotlin 2.0 is a source-breaking change that should not be applied automatically. As a safety net the module is also floored at Java 24: if the Kotlin upgrade cannot be applied (for instance because the version is managed externally by a parent or BOM), the module still lands on Java 24 rather than being left behind, and is raised the rest of the way to Java 25 only once it actually reaches Kotlin 2.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradePluginsForJava11

• Upgrade plugins to Java 11 compatible versions
• Updates plugins to version compatible with Java 11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradePluginsForJava17

• Upgrade plugins to Java 17 compatible versions
• Updates plugins to version compatible with Java 17.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradePluginsForJava21

• Upgrade plugins to Java 21 compatible versions
• Updates plugins and dependencies to version compatible with Java 21.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradePluginsForJava25

• Upgrade plugins to Java 25 compatible versions
• Updates plugins and dependencies to versions compatible with Java 25.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava17

• Migrate to Java 17
• This recipe will apply changes commonly needed when migrating to Java 17. Specifically, for those applications that are built on Java 8, this recipe will update and add dependencies on J2EE libraries that are no longer directly bundled with the JDK. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 17 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 17.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava21

• Migrate to Java 21
• This recipe will apply changes commonly needed when migrating to Java 21. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 21 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 21.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava25

• Migrate to Java 25
• This recipe will apply changes commonly needed when migrating to Java 25. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 25 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 25.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava6

• Migrate to Java 6
• This recipe will apply changes commonly needed when upgrading to Java 6. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava7

• Migrate to Java 7
• This recipe will apply changes commonly needed when upgrading to Java 7. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.UpgradeToJava8

• Migrate to Java 8
• This recipe will apply changes commonly needed when upgrading to Java 8. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.WasDevMvnChangeParentArtifactId

• Change net.wasdev.maven.parent:java8-parent to :parent
• This recipe changes the artifactId of the <parent> tag in the pom.xml from java8-parent to parent.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jacoco.UpgradeJaCoCo

• Upgrade JaCoCo
• This recipe will upgrade JaCoCo to the latest patch version, which traditionally advertises full backwards compatibility for older Java versions.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JacksonJavaxToJakarta

• Migrate Jackson from javax to jakarta namespace
• Java EE has been rebranded to Jakarta EE. This recipe replaces existing Jackson dependencies with their counterparts that are compatible with Jakarta EE 9.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JakartaEE10

• Migrate to Jakarta EE 10
• These recipes help with the Migration to Jakarta EE 10, flagging and updating deprecated methods.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JakartaEE11

• Migrate to Jakarta EE 11
• These recipes help with the Migration to Jakarta EE 11, flagging and updating deprecated methods.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JavaxEjbToJakartaEjb

• Migrate deprecated javax.ejb packages to jakarta.ejb
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JavaxMigrationToJakarta

• Migrate to Jakarta EE 9
• Jakarta EE 9 is the first version of Jakarta EE that uses the new jakarta namespace.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.JavaxXmlBindMigrationToJakartaXmlBind

• Migrate deprecated javax.xml.bind packages to jakarta.xml.bind
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.MigratePluginsForJakarta10

• Update Plugins for Jakarta EE 10
• Update plugin to be compatible with Jakarta EE 10.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.MigratePluginsForJakarta11

• Update Plugins for Jakarta EE 11
• Update plugins to be compatible with Jakarta EE 11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.jakarta.MigratePluginsForJakarta9

• Update Plugins for Jakarta EE 9
• Update plugins to be compatible with Jakarta EE 9.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.javax.AddJaxbAPIDependencies

• Add explicit JAXB API dependencies
• This recipe will add explicit API dependencies for Jakarta EE 8 when a Java 8 application is using JAXB. Any existing dependencies will be upgraded to the latest version of Jakarta EE 8. The artifacts are moved to Jakarta EE 8 version 2.x which allows for the continued use of the javax.xml.bind namespace. Running a full javax to Jakarta migration using org.openrewrite.java.migrate.jakarta.JavaxMigrationToJakarta will update to versions greater than 3.x which necessitates the package change as well.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.javax.AddJaxbDependenciesWithRuntime

• Add explicit JAXB API dependencies and runtime
• This recipe will add explicit dependencies for Jakarta EE 8 when a Java 8 application is using JAXB. Any existing dependencies will be upgraded to the latest version of Jakarta EE 8. The artifacts are moved to Jakarta EE 8 version 2.x which allows for the continued use of the javax.xml.bind namespace. Running a full javax to Jakarta migration using org.openrewrite.java.migrate.jakarta.JavaxMigrationToJakarta will update to versions greater than 3.x which necessitates the package change as well.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.javax.AddJaxbDependenciesWithoutRuntime

• Add explicit JAXB API dependencies and remove runtimes
• This recipe will add explicit API dependencies without runtime dependencies for Jakarta EE 8 when a Java 8 application is using JAXB. Any existing API dependencies will be upgraded to the latest version of Jakarta EE 8. The artifacts are moved to Jakarta EE 8 version 2.x which allows for the continued use of the javax.xml.bind namespace. All JAXB runtime implementation dependencies are removed.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.javax.MigrateJaxBWSPlugin

• Migrate JAXB-WS Plugin
• Upgrade the JAXB-WS Maven plugin to be compatible with Java 11.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.lang.FindNonVirtualExecutors

• Find non-virtual ExecutorService creation
• Find all places where static java.util.concurrent.Executors method creates a non-virtual java.util.concurrent.ExecutorService. This recipe can be used to search fro ExecutorService that can be replaced by Virtual Thread executor.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.migrate.lang.FindVirtualThreadOpportunities

• Find Virtual Thread opportunities
• Find opportunities to convert existing code to use Virtual Threads.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.migrate.lombok.LombokBestPractices

• Lombok Best Practices
• Applies all recipes that enforce best practices for using Lombok.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.migrate.search.AboutJavaVersion

• Find which Java version is in use
• A diagnostic for studying the distribution of Java language version levels (both source and target compatibility across files and source sets).

Data tables:

• org.openrewrite.java.migrate.table.JavaVersionPerSourceSet: A per-source set view of Java version in use.

org.openrewrite.java.migrate.search.FindDataUsedOnDto

• Find data used on DTOs
• Find data elements used on DTOs. This is useful to provide information where data over-fetching may be a problem.

Data tables:

• org.openrewrite.java.migrate.table.DtoDataUses: The use of the data elements of a DTO by the method declaration using it.

org.openrewrite.java.migrate.search.FindInternalJavaxApis

• Find uses of internal javax APIs
• The libraries that define these APIs will have to be migrated before any of the repositories that use them.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.java.migrate.search.FindJavaVersion

• Find Java versions in use
• Finds Java versions in use, emitting one row per git repository (the lowest source/target compatibility across modules in that repository).

Data tables:

• org.openrewrite.java.migrate.table.JavaVersionTable: Records versions of Java in use

org.openrewrite.java.migrate.search.PlanJavaMigration

• Plan a Java version migration
• Study the set of Java versions and associated tools in use across many repositories.

Data tables:

• org.openrewrite.java.migrate.table.JavaVersionMigrationPlan: A per-repository view of the current state of Java versions and associated build tools

rewrite-migrate-kotlin

org.openrewrite.kotlin.migrate.UpgradeKotlinGradlePlugins

• Upgrade Kotlin Gradle plugins to 2.x
• Upgrade all org.jetbrains.kotlin.* Gradle plugins to Kotlin 2.x. This includes the core kotlin-jvm plugin as well as all official Kotlin Gradle plugins such as serialization, Spring, allopen, noarg, JPA, and parcelize.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.kotlin.migrate.UpgradeToKotlin2

• Migrate to Kotlin 2
• Migrate deprecated Kotlin 1.x APIs to their Kotlin 2.x replacements and update Gradle build files for Kotlin 2.x compatibility. Deprecated APIs were deprecated in Kotlin 1.4-1.5 and become errors in Kotlin 2.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-migrate-python

org.openrewrite.python.migrate.DependencyInsight

• Python dependency insight
• Find Python dependencies, including transitive dependencies, matching a package name pattern. Results include the resolved version, scope, and whether the dependency is direct or transitive.

Data tables:

• org.openrewrite.python.table.PythonDependenciesInUse: Direct and transitive dependencies in use in Python projects.

org.openrewrite.python.migrate.FindFutureImports

• Find __future__ imports
• Find __future__ imports and add a search marker. The RemoveFutureImports recipe automatically removes the imports that are obsolete in Python 3.

Data tables:

• org.openrewrite.python.migrate.table.FutureImports: Shows which __future__ features are imported in each source file.

org.openrewrite.python.migrate.FindMethods

• Find Python function and method usages
• Find function and method calls by pattern. Covers standalone functions, class methods, static methods, and constructor calls.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

org.openrewrite.python.migrate.FindTypes

• Find Python types
• Find type references by name. Identifies classes matching a type pattern. In Python, all type definitions use the class keyword, covering regular classes, abstract base classes, protocols, enums, dataclasses, named tuples, typed dicts, and more.

Data tables:

• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

rewrite-netty

org.openrewrite.netty.UpgradeNetty_3_2_to_4_1

• Migrates from Netty 3.2.x to Netty 4.1.x
• Migrate applications to the latest Netty 4.1.x release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-nodejs

org.openrewrite.nodejs.search.DatabaseInteractionInsights

• Javascript database interaction library insights
• Discover which popular javascript database interaction libraries (Sequelize, TypeORM, Mongoose, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.FindNodeProjects

• Find Node.js projects
• Find Node.js projects and summarize data about them.

Data tables:

• org.openrewrite.nodejs.table.NodeProjects: Summary information about Node.js projects.

org.openrewrite.nodejs.search.FormHandlingInsights

• Javascript form handling library insights
• Discover which popular javascript form handling libraries (Formik, React Hook Form, Yup, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.LintingFormattingInsights

• Javascript linting & formatting library insights
• Discover which popular javascript linting and formatting libraries (ESLint, Prettier, Stylelint, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.RealTimeCommunicationInsights

• Javascript real-time communication library insights
• Discover which popular javascript real-time communication libraries (Socket.io, Ws, SockJS, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.SecurityInsights

• Javascript security library insights
• Discover which popular javascript security libraries (Helmet, Cors, Bcrypt, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.ServerSideFrameworksInsights

• Javascript server-side frameworks insights
• Discover which popular javascript server-side frameworks (Express, Koa, Hapi, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.StateManagementInsights

• Javascript state management library insights
• Discover which popular javascript state management libraries (Redux, MobX, Vuex, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.TaskRunnersBuildToolsInsights

• Javascript task runners & build tools insights
• Discover which popular javascript task runners and build tools (Webpack, Parcel, Gulp, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.TestingInsights

• Javascript testing library insights
• Discover which popular javascript testing libraries (Jest, Mocha, Chai, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.UIInsights

• Javascript UI library insights
• Discover which popular javascript UI libraries (React, Vue.js, Angular, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.search.UtilityInsights

• Javascript utility library insights
• Discover which popular javascript utility libraries (Lodash, Moment.js, Date-fns, etc.) are being used in your projects.

Data tables:

• org.openrewrite.javascript.table.NodeDependenciesInUse: Direct and transitive dependencies in use in Node.js projects.

org.openrewrite.nodejs.security.DependencyVulnerabilityCheck

• Find and fix vulnerable npm dependencies
• This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest patch version. If a minor or major upgrade is required to reach the fixed version, this can be controlled using the maximumUpgradeDelta option. Vulnerability information comes from the GitHub Security Advisory Database, which aggregates vulnerability data from several public databases. ## Customizing Vulnerability Data Extend this recipe and override baselineVulnerabilities(ctx) to replace the bundled advisory database, or override supplementalVulnerabilities(ctx) to add organisation-specific advisories alongside the bundled data.

Data tables:

• org.openrewrite.nodejs.table.VulnerabilityReport: Lists all vulnerabilities found in project dependencies.

rewrite-prethink

org.openrewrite.prethink.UpdateAgentConfig

• Update agent configuration files
• Update coding agent configuration files (CLAUDE.md, .cursorrules, etc.) to include references to Moderne Prethink context files in .moderne/context/.

Data tables:

• org.openrewrite.prethink.table.ContextRegistry: Registry of available context files for coding agents.

org.openrewrite.prethink.UpdatePrethinkContext

• Update Prethink context
• Generate FINOS CALM architecture diagram and update agent configuration files. This recipe expects CALM-related data tables (ServiceEndpoints, DatabaseConnections, ExternalServiceCalls, MessagingConnections, etc.) to be populated by other recipes in a composite.

Data tables:

• org.openrewrite.prethink.table.ContextRegistry: Registry of available context files for coding agents.

rewrite-quarkus

org.openrewrite.quarkus.migrate.javaee.AddQuarkus2MavenPlugins

• Migrate JavaEE Maven Dependencies to Quarkus 2
• Upgrade Standard JavaEE dependencies to Quarkus 2 dependencies.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.migrate.javaee.JavaEEtoQuarkus2Migration

• Migrate JavaEE to Quarkus 2
• These recipes help with the migration of a JavaEE application using EJBs and Hibernate to Quarkus 2. Additional transformations like JSF, JMS, Quarkus Tests may be necessary.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.quarkus2.Quarkus1to2Migration

• Quarkus 2.x migration from Quarkus 1.x
• Migrates Quarkus 1.x to 2.x.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-rewrite

org.openrewrite.java.recipes.FindRecipes

• Find OpenRewrite recipes
• This recipe finds all OpenRewrite recipes, primarily to produce a data table that is being used to experiment with fine-tuning a large language model to produce more recipes.

Data tables:

• org.openrewrite.table.RewriteRecipeSource: This table contains the source code of recipes along with their metadata for use in an experiment fine-tuning large language models to produce more recipes.

org.openrewrite.java.recipes.GenerateDeprecatedMethodRecipes

• Generate InlineMethodCalls recipes for deprecated delegating methods
• Finds @Deprecated method declarations whose body is a single delegation call to another method in the same class, and generates a declarative YAML recipe file containing InlineMethodCalls entries for each.

Data tables:

• org.openrewrite.java.recipes.DeprecatedMethodDelegations: Deprecated methods that delegate to another method in the same class, suitable for inlining via InlineMethodCalls.

org.openrewrite.java.recipes.RecipeTestingBestPractices

• Recipe testing best practices
• Best practices for testing recipes.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.recipes.UpgradeTestsToJava21

• Migrate tests to Java 21
• Use Java 21 features in tests.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.recipes.rewrite.OpenRewriteRecipeBestPractices

• OpenRewrite recipe best practices
• Best practices for OpenRewrite recipe development.

Data tables:

• org.openrewrite.java.recipes.DeprecatedMethodDelegations: Deprecated methods that delegate to another method in the same class, suitable for inlining via InlineMethodCalls.
• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-spring

org.openrewrite.java.spring.boot2.SpringBoot2JUnit4to5Migration

• Migrate Spring Boot 2.x projects to JUnit 5 from JUnit 4
• This recipe will migrate a Spring Boot application's tests from JUnit 4 to JUnit 5. This spring-specific migration includes conversion of Spring Test runners to Spring Test extensions and awareness of the composable Spring Test annotations.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_0

• Migrate from Spring Boot 1.x to 2.0
• Migrate Spring Boot 1.x applications to the latest Spring Boot 2.0 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_1

• Migrate to Spring Boot 2.1
• Migrate applications to the latest Spring Boot 2.1 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_2

• Migrate to Spring Boot 2.2
• Migrate applications to the latest Spring Boot 2.2 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.2.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_3

• Migrate to Spring Boot 2.3
• Migrate applications to the latest Spring Boot 2.3 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_4

• Migrate to Spring Boot 2.4
• Migrate applications to the latest Spring Boot 2.4 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.4.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_5

• Upgrade to Spring Boot 2.5
• Upgrade to Spring Boot 2.5 from any prior 2.x version.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_6

• Migrate to Spring Boot 2.6
• Migrate applications to the latest Spring Boot 2.6 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.6.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_7

• Migrate to Spring Boot 2.7
• Upgrade to Spring Boot 2.7.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot2.search.FindUpgradeRequirementsSpringBoot_2_5

• Find patterns that require updating for Spring Boot 2.5
• Looks for a series of patterns that have not yet had auto-remediation recipes developed for.

Data tables:

• org.openrewrite.maven.table.DependenciesDeclared: Direct (first-order) dependencies declared by the project.

org.openrewrite.java.spring.boot2.search.MessagesInTheDefaultErrorView

• Find projects affected by changes to the default error view message attribute
• As of Spring Boot 2.5 the message attribute in the default error view was removed rather than blanked when it is not shown. spring-webmvc or spring-webflux projects that parse the error response JSON may need to deal with the missing item (release notes). You can still use the server.error.include-message property if you want messages to be included.

Data tables:

• org.openrewrite.maven.table.DependenciesDeclared: Direct (first-order) dependencies declared by the project.

org.openrewrite.java.spring.boot3.SpringBoot33BestPractices

• Spring Boot 3.3 best practices
• Applies best practices to Spring Boot 3 applications.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0

• Migrate to Spring Boot 3.0 (Community Edition)
• Migrate applications to the latest Spring Boot 3.0 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 2.7.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_1

• Migrate to Spring Boot 3.1
• Migrate applications to the latest Spring Boot 3.1 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 3.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_2

• Migrate to Spring Boot 3.2
• Migrate applications to the latest Spring Boot 3.2 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 3.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_3

• Migrate to Spring Boot 3.3
• Migrate applications to the latest Spring Boot 3.3 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs, and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework, Spring Data, etc) that are required as part of the migration to Spring Boot 3.2.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_4

• Migrate to Spring Boot 3.4 (Community Edition)
• Migrate applications to the latest Spring Boot 3.4 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_5

• Migrate to Spring Boot 3.5 (Community Edition)
• Migrate applications to the latest Spring Boot 3.5 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot4.MigrateJsonschema2PojoToSpringBoot4

• Migrate jsonschema2pojo configuration to Spring Boot 4
• Update jsonschema2pojo-maven-plugin to generate Jackson 3 and Jakarta Validation annotations compatible with Spring Boot 4. The jackson3 annotation style was introduced in jsonschema2pojo 1.3.0, so the plugin is upgraded to at least that version first.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot4.MigrateOpenApiGeneratorToSpringBoot4

• Migrate OpenAPI Generator spring configuration to Spring Boot 4
• Update openapi-generator-maven-plugin executions using the spring generator to generate Spring Boot 4 and Jackson 3 sources. Replaces the deprecated useSpringBoot3 option with useSpringBoot4 and enables useJackson3, matching the Jackson 3 baseline of Spring Boot 4. Enabling useSpringBoot4 also enables useJakartaEe, so it is left implicit. The useSpringBoot4/useJackson3 options were introduced in OpenAPI Generator 7.16.0, so the plugin is upgraded to at least that version first.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.boot4.UpgradeSpringBoot_4_0

• Migrate to Spring Boot 4.0 (Community Edition)
• Migrate applications to the latest Spring Boot 4.0 release. This recipe will modify an application's build files, make changes to deprecated/preferred APIs.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.cloud2025.AddSpringCloudDependenciesBom

• Add Spring Cloud dependencies BOM
• Adds the Spring Cloud dependencies BOM as a managed import, but only when the project already uses a Spring Cloud dependency. Prevents accidentally introducing the BOM into unrelated projects.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.cloud2025.UpgradeSpringCloud_2025_1

• Migrate to Spring Cloud 2025.1
• Migrate applications to the latest Spring Cloud 2025.1 release, compatible with Spring Boot 4.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.framework.UpgradeSpringFramework_6_0

• Migrate to Spring Framework 6.0 (Community Edition)
• Migrate applications to the latest Spring Framework 6.0 release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.framework.UpgradeSpringFramework_6_1

• Migrate to Spring Framework 6.1
• Migrate applications to the latest Spring Framework 6.1 release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.framework.UpgradeSpringFramework_6_2

• Migrate to Spring Framework 6.2
• Migrate applications to the latest Spring Framework 6.2 release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.framework.UpgradeSpringFramework_7_0

• Migrate to Spring Framework 7.0
• Migrate applications to the latest Spring Framework 7.0 release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.spring.http.SpringWebDependency

• Find Spring Web dependency
• Find compile scoped Spring Web dependency for Maven and Gradle, both direct and transitive.

Data tables:

• org.openrewrite.maven.table.DependenciesInUse: Direct and transitive dependencies in use.
• org.openrewrite.maven.table.ExplainDependenciesInUse: A dependency graph explainer similar to that shown by gradle dependencyInsight for each matching dependency. This table will contain a row per matching dependency per configuration per (sub)project.

org.openrewrite.java.spring.search.FindApiCalls

• Find HTTP API calls via RestTemplate
• Find outbound HTTP API calls made via Spring's RestTemplate class.

Data tables:

• org.openrewrite.java.spring.table.ApiCalls: The API endpoints that applications expose.

org.openrewrite.java.spring.search.FindApiEndpoints

• Find Spring API endpoints
• Find all HTTP API endpoints exposed by Spring applications. More specifically, this marks method declarations annotated with @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, and @PatchMapping as search results.

Data tables:

• org.openrewrite.java.spring.table.ApiEndpoints: The API endpoints that applications expose.

org.openrewrite.java.spring.search.FindConfigurationProperties

• Find Spring @ConfigurationProperties
• Find all classes annotated with @ConfigurationProperties and extract their prefix values. This is useful for discovering all externalized configuration properties in Spring Boot applications.

Data tables:

• org.openrewrite.java.spring.table.ConfigurationPropertiesTable: Classes annotated with @ConfigurationProperties and their prefix values.

org.openrewrite.java.spring.search.FindSpringComponents

• Find Spring components
• Find Spring components, including controllers, services, repositories, return types of @Bean annotated methods, etc.

Data tables:

• org.openrewrite.java.spring.table.SpringComponents: Classes defined with a form of a Spring @Component stereotype and types returned from @Bean annotated methods.
• org.openrewrite.java.spring.table.SpringComponentRelationships: A table of relationships between Spring components.

org.openrewrite.java.spring.security5.search.FindEncryptorsQueryableTextUses

• Finds uses of Encryptors.queryableText()
• Encryptors.queryableText() is insecure and is removed in Spring Security 6.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

rewrite-spring-to-quarkus

org.openrewrite.quarkus.spring.CustomizeQuarkusVersion

• Customize Quarkus BOM Version
• Allows customization of the Quarkus BOM version used in the migration. By default uses 3.x (latest 3.x version), but can be configured to use a specific version.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.spring.SpringBootToQuarkus

• Migrate Spring Boot to Quarkus
• Replace Spring Boot with Quarkus.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-sql

org.openrewrite.sql.ChangeFunctionName

• Change a SQL function name
• When migrating between dialects, often one name can be substituted for another. For example, Oracle's NVL function can be replaced with Postgres COALESCE.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.ConvertOracleFunctionsToPostgres

• Convert Oracle functions to PostgreSQL
• Replaces Oracle-specific functions with PostgreSQL equivalents.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.ConvertSqlServerFunctionsToPostgres

• Convert SQL Server functions to PostgreSQL
• Replaces SQL Server-specific functions with PostgreSQL equivalents.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.FindSql

• Find SQL in code and resource files
• Find SQL in code (e.g. in string literals) and in resources like those ending with .sql.

Data tables:

• org.openrewrite.sql.table.DatabaseColumnsUsed: Shows which database columns are read/written by a SQL statement.

org.openrewrite.sql.MigrateOracleToPostgres

• Migrate Oracle SQL to PostgreSQL
• Converts Oracle-specific SQL syntax and functions to PostgreSQL equivalents.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.MigrateSqlServerToPostgres

• Migrate SQL Server to PostgreSQL
• Converts Microsoft SQL Server-specific SQL syntax and functions to PostgreSQL equivalents.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.antipattern.FindCartesianJoin

• Find cartesian joins
• Joins that lack a real linking predicate multiply row counts instead of matching related rows: an ON condition comparing a column to itself is always true, and comma-separated tables with no WHERE predicate relating them pair every row with every row. Explicit CROSS JOIN and NATURAL joins are treated as intentional and are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindConstantPredicate

• Find constant predicates that are always true or always false
• A comparison whose operands are both constant, such as 1 = 1 or 1 = 0, evaluates the same for every row regardless of the data. Combined with OR an always-true constant makes the whole condition always true, so every row matches and the other filters are ignored; an always-false constant used as a filter can never be satisfied, so the query returns nothing. An always-true constant on its own or joined with AND, a common query-builder idiom, is not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindCorrelatedAggregateSubquery

• Find correlated aggregate subqueries in WHERE
• A scalar subquery that computes an aggregate like MAX while referencing the outer query runs once per outer row on engines that cannot decorrelate it. A window function or a join to a pre-aggregated derived table computes every group in a single pass. Uncorrelated aggregate subqueries and EXISTS or IN subqueries are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindCountAsExistenceCheck

• Find COUNT subqueries used as existence checks
• A scalar COUNT subquery compared to 0 or 1 tallies every matching row even though the outcome is decided by the first one. EXISTS or NOT EXISTS lets the engine stop as soon as a match is found. Comparisons against other values, such as > 5, express a genuine cardinality requirement and are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindDistinctWithJoin

• Find DISTINCT masking join fan-out
• DISTINCT paired with a JOIN frequently compensates for row multiplication that a correct join condition or an EXISTS test would avoid, and DISTINCT alongside GROUP BY is redundant because grouping already collapses duplicate rows. A DISTINCT on a single-table query without GROUP BY is not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindDmlWithoutWhere

• Find UPDATE and DELETE statements without a WHERE clause
• An UPDATE or DELETE with no WHERE clause touches every row in the table, holding locks for the duration, flooding replication, and risking unintended data loss if the missing predicate was an oversight.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindHavingWithoutAggregate

• Find HAVING conditions that use no aggregate
• A HAVING condition that references no aggregate forces the database to build every group before throwing unwanted ones away. The same condition in WHERE filters rows before grouping, doing strictly less work.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindInsertWithoutColumns

• Find INSERT ... VALUES statements that omit the column list
• An INSERT ... VALUES with no column list binds each value to a column by position, so adding, dropping, or reordering a column silently shifts values into the wrong columns or breaks the statement; naming the target columns keeps it correct across schema changes. INSERT ... SELECT is left alone, since its projection makes the column correspondence explicit.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindLeadingWildcardLike

• Find LIKE patterns starting with a wildcard
• A LIKE pattern whose first character is % or _ gives the database no prefix to seek in a B-tree index, so every row must be inspected. When a prefix search is not possible, a trigram or full-text index can serve the query instead. Parameter placeholders and patterns with only trailing wildcards are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindLimitWithoutOrderBy

• Find row limiters without an ORDER BY
• A LIMIT, OFFSET, FETCH, or TOP clause selects a subset of rows, but without an ORDER BY the engine is free to return any rows in any order, so the result is arbitrary and can differ from one execution to the next. Queries that can only ever produce a single row, such as a bare aggregate with no GROUP BY, and limiters inside an EXISTS subquery, where order does not matter, are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindNonSargablePredicate

• Find non-sargable predicates
• A comparison that wraps a column in a function, CAST, or arithmetic must evaluate the expression for every row, so an index on the bare column cannot be used for a range scan. Keeping the column alone on one side, e.g. amount > 100 - 1 rather than amount + 1 > 100, keeps the predicate index-eligible.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindNotInSubquery

• Find NOT IN with a subquery
• When the subquery can return a NULL, NOT IN evaluates to unknown for every row and the outer query silently returns nothing. Many planners also fail to rewrite NOT IN as an efficient anti-join. NOT EXISTS avoids both problems. NOT IN over a literal list is not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindOffsetPagination

• Find OFFSET-based pagination
• OFFSET n reads and throws away n rows before returning any, so each later page costs linearly more than the one before it. Parameterized offsets and large literal offsets are flagged; keyset pagination (WHERE key > last-seen ORDER BY key) reads only the requested page. Small literal offsets are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindOptionalParameterOr

• Find optional filters written as OR parameter IS NULL
• The col = ? OR ? IS NULL pattern turns a filter on and off at runtime, so the planner must settle on one generic plan that works for every parameter combination instead of an index-driven plan for the filtered case. An IS NULL test on a column inside an OR is ordinary SQL and is not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindOrderByRandom

• Find ORDER BY on a random function
• Sorting by RAND(), RANDOM(), NEWID(), or DBMS_RANDOM computes a random value for every row and sorts the entire table just to keep a few rows. Sample by a key range or use the dialect's table sampling instead.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindOversizedInList

• Find oversized IN lists
• A very long IN list is parsed and planned on every execution, tends to pollute the statement cache, and some databases hard-cap the number of elements it may contain. Loading the values into a temporary table and joining against it scales far better. IN with a subquery is not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindScalarSubqueryInSelect

• Find scalar subqueries in the SELECT list
• A subquery used as an expression in the SELECT list may execute once per result row, turning a single scan into N+1 queries. A JOIN (or LATERAL join) produces the same values in one pass. Subqueries in WHERE, FROM, or JOIN conditions are not flagged.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindSelectStar

• Find SELECT * queries
• Wildcard projections fetch columns the code does not use, defeat covering indexes, and change behavior when the schema changes. SELECT * under EXISTS (...) or inside aggregate functions like COUNT(*) is not flagged because no columns are materialized there.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.FindUnionInsteadOfUnionAll

• Find UNION where UNION ALL may suffice
• Plain UNION de-duplicates the combined rows, forcing a sort or hash over the entire result even when the branches cannot overlap. UNION ALL skips that work. UNION inside a WITH item is not flagged because recursive CTEs rely on plain UNION semantics to terminate.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.RemoveOrderByInSubquery

• Remove redundant ORDER BY from subqueries
• An ORDER BY inside a subquery or CTE without a LIMIT, OFFSET, or FETCH does not affect the rows the outer query returns, so the database either discards the sort or pays for ordering that nothing observes. Remove the clause, leaving the rest of the statement untouched. Sort in the outermost query if a specific order is required.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.ReplaceNullComparisonWithIsNull

• Replace = NULL and <> NULL with IS NULL and IS NOT NULL
• Under three-valued logic a comparison with NULL evaluates to UNKNOWN rather than true, so col = NULL and col <> NULL match no rows. Rewrite them to the intended col IS NULL and col IS NOT NULL, changing only the compared operator so the rest of the statement is left untouched.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.antipattern.SqlAntiPatterns

• Find and fix SQL performance anti-patterns
• Analyzes SQL found in code and resource files for statically detectable performance anti-patterns such as SELECT *, COUNT(*) used as an existence check, scalar subqueries in the SELECT list, non-sargable predicates, and missing join conditions. Every occurrence is reported to the SqlAntiPatterns data table with a severity and suggested remediation, then fixed in place where a safe rewrite exists or marked in source otherwise.

Data tables:

• org.openrewrite.sql.table.SqlAntiPatterns: SQL statements matching performance anti-pattern rules.

org.openrewrite.sql.search.FindFunction

• Find SQL function
• Find SQL functions by name.

Data tables:

• org.openrewrite.sql.table.DatabaseQueries: Shows matching SQL queries.
• org.openrewrite.sql.table.DatabaseFunctions: Shows matching SQL functions and the queries that contain them.

org.openrewrite.sql.search.FindStoredProcedureCall

• Find stored procedure calls
• Find stored procedures invoked from SQL via EXEC, EXECUTE, or CALL. Useful for taking inventory of the stored procedures a codebase depends on when planning a database migration.

Data tables:

• org.openrewrite.sql.table.StoredProcedureCalls: Shows stored procedures invoked from SQL, e.g. via EXEC, EXECUTE, or CALL.

rewrite-static-analysis

org.openrewrite.staticanalysis.FindMissingJavadocOnPublicMethods

• Find public methods missing Javadoc
• Locates public method declarations that are not documented with a Javadoc comment, marks them with a search result, and records them in a data table.

Data tables:

• org.openrewrite.staticanalysis.table.MissingJavadocOnPublicMethods: Public method declarations that are not documented with a Javadoc comment.

org.openrewrite.staticanalysis.FindNewExceptionWithoutCause

• Find new exceptions thrown without the caught exception
• Finds catch blocks that throw a newly created exception without referencing the caught exception, which discards the original exception's stack trace and message. Data flow (taint) tracking is used to establish whether the caught exception—or any value derived from it—reaches the thrown exception, so indirect references through local variables and string concatenation are not falsely reported. This mirrors PMD's PreserveStackTrace rule.

Data tables:

• org.openrewrite.staticanalysis.table.ExceptionsWithoutCause: New exceptions thrown from a catch block that do not reference the caught exception.

org.openrewrite.staticanalysis.ModernizeCollections

• Modernize collections
• Replace the legacy synchronized types Hashtable, Vector, Stack, and StringBuffer with their modern unsynchronized counterparts HashMap, ArrayList, Deque/ArrayDeque, and StringBuilder. Each replacement is only applied when data flow analysis can prove the instance is a local variable that never escapes its method, so the synchronization it provided is redundant.

Data tables:

• org.openrewrite.staticanalysis.table.LegacySynchronizedTypesNotMigrated: Instances of a legacy synchronized type (Hashtable, Vector, Stack, StringBuffer) that were found but left unchanged because they could not be proven safe to modernize.

org.openrewrite.staticanalysis.ReplaceHashtableWithHashMap

• Replace java.util.Hashtable with java.util.HashMap
• Hashtable synchronizes every operation, which adds overhead in the common single-threaded case. This recipe replaces a local Hashtable with a HashMap when data flow analysis can prove the Hashtable never escapes its method (it is not returned, assigned to a field, or passed as an argument), so no other thread can observe it and the synchronization is redundant. Fields, escaping variables, and Hashtable-specific method usages (contains, elements, keys) are left untouched. HashMap permits null keys and values, so it accepts every input Hashtable did.

Data tables:

• org.openrewrite.staticanalysis.table.LegacySynchronizedTypesNotMigrated: Instances of a legacy synchronized type (Hashtable, Vector, Stack, StringBuffer) that were found but left unchanged because they could not be proven safe to modernize.

org.openrewrite.staticanalysis.ReplaceStringBufferWithStringBuilder

• Replace java.lang.StringBuffer with java.lang.StringBuilder
• StringBuffer synchronizes every operation, which adds overhead in the common single-threaded case. StringBuilder exposes the identical API without the synchronization. This recipe replaces a local StringBuffer with a StringBuilder when data flow analysis can prove the StringBuffer never escapes its method (it is not returned, assigned to a field, or passed as an argument), so no other thread can observe it and the synchronization is redundant. Fields and escaping variables are left untouched.

Data tables:

• org.openrewrite.staticanalysis.table.LegacySynchronizedTypesNotMigrated: Instances of a legacy synchronized type (Hashtable, Vector, Stack, StringBuffer) that were found but left unchanged because they could not be proven safe to modernize.

org.openrewrite.staticanalysis.ReplaceVectorWithArrayList

• Replace java.util.Vector with java.util.ArrayList
• Vector synchronizes every operation, which adds overhead in the common single-threaded case. This recipe replaces a local Vector with an ArrayList when data flow analysis can prove the Vector never escapes its method (it is not returned, assigned to a field, or passed as an argument), so no other thread can observe it and the synchronization is redundant. Fields, escaping variables, Vector-specific method usages (like elementAt or addElement), and the Vector(int, int) constructor are left untouched.

Data tables:

• org.openrewrite.staticanalysis.table.LegacySynchronizedTypesNotMigrated: Instances of a legacy synchronized type (Hashtable, Vector, Stack, StringBuffer) that were found but left unchanged because they could not be proven safe to modernize.

org.openrewrite.staticanalysis.UseLambdaForFunctionalInterface

• Use lambda expressions instead of anonymous classes
• Instead of anonymous class declarations, use a lambda where possible. Using lambdas to replace anonymous classes can lead to more expressive and maintainable code, improve code readability, reduce code duplication, and achieve better performance in some cases.

Data tables:

• org.openrewrite.staticanalysis.table.AnonymousFunctionalInterfaceImplementations: Every anonymous class that implements a functional interface, whether or not it could be rewritten to a lambda, plus the sites that could not be decided either way because the supertype carries incomplete type attribution. Sites that were not rewritten carry the reason why.

org.openrewrite.staticanalysis.UseMapEntrySetIteration

• Iterate a Map's entrySet() rather than its keySet()
• A loop over map.keySet() that calls map.get(key) hashes and probes the map again for every element, which on a TreeMap costs an extra O(log n) lookup per iteration. Iterating map.entrySet() instead hands the loop both the key and the value. The loop is only rewritten when: - The map is a simple reference that is neither modified nor reassigned inside the loop. - get is called only with the loop variable. - The loop variable is neither reassigned nor captured by a lambda or anonymous class. Every candidate loop, converted or not, is recorded in a data table along with the reason it was left alone.

Data tables:

• org.openrewrite.staticanalysis.table.MapKeySetIterations: Loops that iterate a map's keySet() and look the value up again with get(key), and whether they were converted to entrySet() iteration.

rewrite-struts

org.openrewrite.java.struts.migrate6.MigrateStaticOgnlMethodAccess

• Migrate static OGNL method access to action wrapper methods
• Migrates OGNL expressions using static method access (e.g., @com.app.Util@makeCode()) to use action wrapper methods instead. Static method access is disabled by default in Struts 6 for security reasons.

Data tables:

• org.openrewrite.java.struts.table.StaticOgnlMethodAccess: Locations where OGNL expressions use static method access, which is disabled by default in Struts 6.

org.openrewrite.java.struts.migrate6.MigrateStruts6

• Migrate to Struts 6.0
• Migrate Struts 2.x to Struts 6.0.

Data tables:

• org.openrewrite.java.struts.table.StaticOgnlMethodAccess: Locations where OGNL expressions use static method access, which is disabled by default in Struts 6.

org.openrewrite.java.struts.migrate7.MigrateStruts7

• Migrate to Struts 7.0
• Migrate Struts 6.x to Struts 7.x.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.struts.search.FindStaticOgnlMethodAccess

• Find static OGNL method access
• Find OGNL expressions that use static method access (e.g., @com.app.Util@makeCode()), which is disabled by default in Struts 6 for security reasons. These expressions need to be migrated to use action instance methods instead.

Data tables:

• org.openrewrite.java.struts.table.StaticOgnlMethodAccess: Locations where OGNL expressions use static method access, which is disabled by default in Struts 6.

org.openrewrite.java.struts.search.FindStrutsActions

• Find Struts actions
• Find actions and their associated definitions.

Data tables:

• org.openrewrite.java.struts.table.StrutsActions: Definition of struts action.

rewrite-terraform

org.openrewrite.terraform.search.FindRequiredProvider

• Find required providers
• Find required_providers blocks in Terraform configuration files. Produces a data table of the provider names and their versions.

Data tables:

• org.openrewrite.terraform.table.RequiredProviders: A list of required providers in the Terraform configuration.

rewrite-testing-frameworks

org.openrewrite.java.testing.assertj.Assertj

• AssertJ best practices
• Migrates JUnit asserts to AssertJ and applies best practices to assertions.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.testing.assertj.JUnitToAssertj

• Migrate JUnit asserts to AssertJ
• AssertJ provides a rich set of assertions, truly helpful error messages, improves test code readability. Converts assertions from org.junit.jupiter.api.Assertions to org.assertj.core.api.Assertions. Will convert JUnit 4 to JUnit Jupiter if necessary to match and modify assertions.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.testing.junit.JUnit6BestPractices

• JUnit 6 best practices
• Applies best practices to tests.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.testing.junit5.JUnit4to5Migration

• JUnit Jupiter migration from JUnit 4.x
• Migrates JUnit 4.x tests to JUnit Jupiter.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.testing.junit5.JUnit5BestPractices

• JUnit 5 best practices
• Applies best practices to tests.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.java.testing.junit6.JUnit5to6Migration

• JUnit 6 migration from JUnit 5.x
• Migrates JUnit 5.x tests to JUnit 6.x.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

rewrite-third-party

ai.timefold.solver.migration.FromOptaPlannerToTimefoldSolver

• Migrate from OptaPlanner to Timefold Solver
• Replaces your method/field calls, GAVs, etc. To replace deprecated methods too, use the recipe ToLatest

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

ai.timefold.solver.migration.ToLatest

• Upgrade to the latest Timefold Solver
• Replace all your calls to deleted/deprecated types and methods of Timefold Solver with their proper alternatives.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

ai.timefold.solver.migration.fork.TimefoldChangeDependencies

• Migrate all Maven and Gradle groupIds and artifactIds from OptaPlanner to Timefold
• Migrate all Maven and Gradle groupIds and artifactIds from OptaPlanner to Timefold.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.CheckAndCommentOutDeprecations1412

• Report types deprecated or removed in WebLogic version 14.1.2
• This recipe will report Java types that have been deprecated or removed in WebLogic version 14.1.2. This is an alias to prevent breaking existing recipes.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.CheckAndCommentOutDeprecations1511

• Report types deprecated or removed in WebLogic version 15.1.1
• This recipe will report Java types that have been deprecated or removed in WebLogic version 15.1.1. This is an alias to prevent breaking existing recipes.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.JakartaEE9_1

• Migrate to Jakarta EE 9.1
• These recipes help with Migration to Jakarta EE 9.1, flagging and updating deprecated methods.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.ReportDeprecated

• Report uses of Java types deprecated or removed in WebLogic
• This recipe will report uses of Java types that have been deprecated or removed in WebLogic.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.

com.oracle.weblogic.rewrite.ReportDeprecatedOrRemoved1412

• Report types deprecated or removed in WebLogic version 14.1.2
• This recipe will report Java types that have been deprecated or removed in WebLogic version 14.1.2.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.ReportDeprecatedOrRemoved1511

• Report types deprecated or removed in WebLogic version 15.1.1
• This recipe will report Java types that have been deprecated or removed in WebLogic version 15.1.1.

Data tables:

• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.UpdateBuildToWebLogic1412

• Update the WebLogic version to 14.1.2
• This recipe will update the WebLogic version to 14.1.2 for Maven build.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.UpdateBuildToWebLogic1511

• Update the WebLogic version to 15.1.1
• This recipe will update the WebLogic version to 15.1.1 for Maven build.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.UpgradeTo1411

• Migrate to WebLogic 14.1.1
• This recipe will apply changes required for migrating to WebLogic 14.1.1

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.UpgradeTo1412

• Migrate to WebLogic 14.1.2
• This recipe will apply changes required for migrating to WebLogic 14.1.2

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.UpgradeTo1511

• Migrate to WebLogic 15.1.1
• This recipe will apply changes required for migrating to WebLogic 15.1.1 and Jakarta EE 9.1

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.
• org.openrewrite.java.table.MethodCalls: The text of matching method invocations.
• org.openrewrite.java.table.TypeUses: The source code of matching type uses.

com.oracle.weblogic.rewrite.jakarta.UpgradeMavenPluginArtifactItems

• Upgrade group, artifact ID and version of an artifactItem, of a maven plugin execution configuration
• Change the groupId and the artifactId of an artifactItem in the configuration section of a plugin's execution. This recipe does not perform any validation and assumes all values passed are valid.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.jakarta.UpgradeMavenPluginConfigurationArtifacts

• Change artifacts for a Maven plugin configuration
• Change artifacts for a Maven plugin configuration artifacts.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

com.oracle.weblogic.rewrite.spring.framework.UpgradeToSpringFramework_6_2

• Migrate to Spring Framework 6.2 for WebLogic 15.1.1
• Migrate applications to the Spring Framework 6.2 release and compatibility with WebLogic 15.1.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.camel.camel412.CamelQuarkusMigrationRecipe

• Migrates camel 4.11 application to camel 4.12
• Migrates camel 4.11 quarkus application to camel 4.12.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.camel.camel413.CamelQuarkusMigrationRecipe

• Migrates camel 4.12 application to camel 4.13
• Migrates camel 4.12 Quarkus application to camel 4.13.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.camel.camel420.CamelQuarkusMigrationRecipe

• Migrates camel 4.18 application to camel 4.20
• Migrates camel 4.18 Quarkus application to camel 4.20.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.camel.camel47.CamelQuarkusMigrationRecipe

• Migrates camel 4.4 application to camel 4.8
• Migrates camel 4.4 quarkus application to camel 4.8.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.AdditionalChanges

• io.quarkus.updates.core.quarkus30.AdditionalChanges

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JacksonJavaxToJakarta

• Migrate Jackson from javax to jakarta namespace
• Java EE has been rebranded to Jakarta EE. This recipe replaces existing Jackson dependencies with their counterparts that are compatible with Jakarta EE.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxActivationMigrationToJakartaActivation

• Migrate deprecated javax.activation packages to jakarta.activation
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxAnnotationMigrationToJakartaAnnotation

• Migrate deprecated javax.annotation packages to jakarta.annotation
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxAuthenticationMigrationToJakartaAuthentication

• Migrate deprecated javax.security.auth.message packages to jakarta.security.auth.message
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxAuthorizationMigrationToJakartaAuthorization

• Migrate deprecated javax.security.jacc packages to jakarta.security.jacc
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxBatchMigrationToJakartaBatch

• Migrate deprecated javax.batch packages to jakarta.batch
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxDecoratorToJakartaDecorator

• Migrate deprecated javax.decorator packages to jakarta.decorator
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxEjbToJakartaEjb

• Migrate deprecated javax.ejb packages to jakarta.ejb
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxElToJakartaEl

• Migrate deprecated javax.el packages to jakarta.el
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxEnterpriseToJakartaEnterprise

• Migrate deprecated javax.enterprise packages to jakarta.enterprise
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxFacesToJakartaFaces

• Migrate deprecated javax.faces packages to jakarta.faces
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxInjectMigrationToJakartaInject

• Migrate deprecated javax.inject packages to jakarta.inject
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxInterceptorToJakartaInterceptor

• Migrate deprecated javax.interceptor packages to jakarta.interceptor
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxJmsToJakartaJms

• Migrate deprecated javax.jms packages to jakarta.jms
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxJsonToJakartaJson

• Migrate deprecated javax.json packages to jakarta.json
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxJwsToJakartaJws

• Migrate deprecated javax.jws packages to jakarta.jws
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxMailToJakartaMail

• Migrate deprecated javax.mail packages to jakarta.mail
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxPersistenceToJakartaPersistence

• Migrate deprecated javax.persistence packages to jakarta.persistence
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxResourceToJakartaResource

• Migrate deprecated javax.resource packages to jakarta.resource
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxSecurityToJakartaSecurity

• Migrate deprecated javax.security.enterprise packages to jakarta.security.enterprise
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxServletToJakartaServlet

• Migrate deprecated javax.servlet packages to jakarta.servlet
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxTransactionMigrationToJakartaTransaction

• Migrate deprecated javax.transaction packages to jakarta.transaction
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxValidationMigrationToJakartaValidation

• Migrate deprecated javax.validation packages to jakarta.validation
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxWebsocketToJakartaWebsocket

• Migrate deprecated javax.websocket packages to jakarta.websocket
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxWsToJakartaWs

• Migrate deprecated javax.ws packages to jakarta.ws
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxXmlBindMigrationToJakartaXmlBind

• Migrate deprecated javax.xml.bind packages to jakarta.xml.bind
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxXmlSoapToJakartaXmlSoap

• Migrate deprecated javax.soap packages to jakarta.soap
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.JavaxXmlWsMigrationToJakartaXmlWs

• Migrate deprecated javax.xml.ws packages to jakarta.xml.ws
• Java EE has been rebranded to Jakarta EE, necessitating a package relocation.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.RestAssuredJavaxToJakarta

• Migrate RestAssured from javax to jakarta namespace by upgrading to a version compatible with J2EE9
• Java EE has been rebranded to Jakarta EE. This recipe replaces existing RestAssured dependencies with their counterparts that are compatible with Jakarta EE.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus30.UpgradeQuarkiverse

• io.quarkus.updates.core.quarkus30.UpgradeQuarkiverse

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus310.FlywayDb2

• io.quarkus.updates.core.quarkus310.FlywayDb2

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus310.FlywayDerby

• io.quarkus.updates.core.quarkus310.FlywayDerby

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus310.FlywayPostgreSQL

• io.quarkus.updates.core.quarkus310.FlywayPostgreSQL

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus310.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus310.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus311.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus311.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus312.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus312.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus313.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus313.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus324.ReplaceNewJpaModelgenAnnotationProcessor

• io.quarkus.updates.core.quarkus324.ReplaceNewJpaModelgenAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus324.ReplaceOldJpaModelgenAnnotationProcessor

• io.quarkus.updates.core.quarkus324.ReplaceOldJpaModelgenAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus339.ReplaceHibernateProcessorAnnotationProcessor

• io.quarkus.updates.core.quarkus339.ReplaceHibernateProcessorAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus339.ReplaceNewJpaModelgenAnnotationProcessor

• io.quarkus.updates.core.quarkus339.ReplaceNewJpaModelgenAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus339.ReplaceOldJpaModelgenAnnotationProcessor

• io.quarkus.updates.core.quarkus339.ReplaceOldJpaModelgenAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.ChangeMavenCompilerAnnotationProcessorGroupIdAndArtifactId

• Change Maven Compiler plugin annotation processor groupId, artifactId and/or the version
• Change the groupId, artifactId and/or the version of a specified Maven Compiler plugin annotation processor.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.MavenPlugins

• io.quarkus.updates.core.quarkus37.MavenPlugins

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.ReplaceJpaModelgenAnnotationProcessor

• io.quarkus.updates.core.quarkus37.ReplaceJpaModelgenAnnotationProcessor

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus37.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.SyncMavenCompilerAnnotationProcessorVersion

• Sync Maven Compiler plugin annotation processor version with the one provided by the BOM
• Sync Maven Compiler plugin annotation processor version with the one provided by the BOM.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus37.UpgradeToJava17

• Migrate to Java 17
• This recipe will apply changes commonly needed when migrating to Java 17. Specifically, for those applications that are built on Java 8, this recipe will update and add dependencies on J2EE libraries that are no longer directly bundled with the JDK. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 17 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 17.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus38.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus38.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

io.quarkus.updates.core.quarkus39.SyncHibernateJpaModelgenVersionWithBOM

• io.quarkus.updates.core.quarkus39.SyncHibernateJpaModelgenVersionWithBOM

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.Camel410LTSMigrationRecipe

• Migrate to 4.10.6
• Migrates Apache Camel application to 4.10.6.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.Camel418LTSMigrationRecipe

• Migrate to Camel 4.18LTS
• Migrates Apache Camel application to 4.18 LTS. This recipe aggregates all migration steps from 4.0 to 4.18.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.CamelMigrationRecipe

• Migrate to 4.21.0
• Migrates Apache Camel application to 4.21.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.UpgradeToJava17

• Migrate to Java 17
• This recipe will apply changes commonly needed when migrating to Java 17. Specifically, for those applications that are built on Java 8, this recipe will update and add dependencies on J2EE libraries that are no longer directly bundled with the JDK. This recipe will also replace deprecated API with equivalents when there is a clear migration strategy. Build files will also be updated to use Java 17 as the target/source and plugins will be also be upgraded to versions that are compatible with Java 17.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel412.CamelMigrationRecipe

• Migrates camel 4.11 application to camel 4.12
• Migrates camel 4.11 application to camel 4.12.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel412.scanClassesMovedMaven

• The package scan classes has moved from camel-base-engine to camel-support - maven
• The package scan classes has moved from camel-base-engine to camel-support JAR and moved to a new package - maven.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel413.CamelMigrationRecipe

• Migrates camel 4.12 application to camel 4.13
• Migrates camel 4.12 application to camel 4.13.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel413.furyDependency

• Change Maven dependency example

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel419.CamelMigrationRecipe

• Migrates camel 4.18 application to camel 4.19
• Migrates camel 4.18 application to camel 4.19.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel419.migrateGroovyXml

• Migrate camel-groovy-xml to camel-groovy
• camel-groovy-xml has been removed and moved into camel-groovy. Changes the dependency from camel-groovy-xml to camel-groovy.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel46.CamelMigrationRecipe

• Migrates camel 4.5 application to camel 4.6
• Migrates camel 4.5 application to camel 4.6.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.camel.upgrade.camel46.renamedDependencies

• Renamed dependencies
• Renamed dependencies.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.wicket.BestPractices

• Wicket best practices
• Applies Wicket best practices such as minimizing anonymous inner classes and upgrading to the latest version.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.apache.wicket.MigrateToWicket10

• Migrate to Wicket 10.x
• Migrates Wicket 9.x to Wicket 10.x, as well as Java 17 and Jakarta.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.axonframework.migration.UpgradeAxonFramework_4_Jakarta

• Upgrade to Axonframework 4.x Jakarta
• Migration file to upgrade from an Axon Framework Javax-specific project to Jakarta.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.axonframework.migration.UpgradeAxonFramework_4_Javax

• Upgrade to Axonframework 4.x Javax
• Migration file to upgrade an Axon Framework Javax-specific project and remain on Javax.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_0_0

• Quarkus Updates Aggregate 3.0.0
• Quarkus update recipes to upgrade your application to 3.0.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_10_0

• Quarkus Updates Aggregate 3.10.0
• Quarkus update recipes to upgrade your application to 3.10.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_11_0

• Quarkus Updates Aggregate 3.11.0
• Quarkus update recipes to upgrade your application to 3.11.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_12_0

• Quarkus Updates Aggregate 3.12.0
• Quarkus update recipes to upgrade your application to 3.12.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_13_0

• Quarkus Updates Aggregate 3.13.0
• Quarkus update recipes to upgrade your application to 3.13.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_15_0

• Quarkus Updates Aggregate 3.15.0
• Quarkus update recipes to upgrade your application to 3.15.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_17_0

• Quarkus Updates Aggregate 3.17.0
• Quarkus update recipes to upgrade your application to 3.17.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_18_0

• Quarkus Updates Aggregate 3.18.0
• Quarkus update recipes to upgrade your application to 3.18.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_19_0

• Quarkus Updates Aggregate 3.19.0
• Quarkus update recipes to upgrade your application to 3.19.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_1_0

• Quarkus Updates Aggregate 3.1.0
• Quarkus update recipes to upgrade your application to 3.1.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_20_1

• Quarkus Updates Aggregate 3.20.1
• Quarkus update recipes to upgrade your application to 3.20.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_21_0

• Quarkus Updates Aggregate 3.21.0
• Quarkus update recipes to upgrade your application to 3.21.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_22_0

• Quarkus Updates Aggregate 3.22.0
• Quarkus update recipes to upgrade your application to 3.22.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_23_0

• Quarkus Updates Aggregate 3.23.0
• Quarkus update recipes to upgrade your application to 3.23.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_24_0

• Quarkus Updates Aggregate 3.24.0
• Quarkus update recipes to upgrade your application to 3.24.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_25_0

• Quarkus Updates Aggregate 3.25.0
• Quarkus update recipes to upgrade your application to 3.25.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_26_0

• Quarkus Updates Aggregate 3.26.0
• Quarkus update recipes to upgrade your application to 3.26.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_29_0

• Quarkus Updates Aggregate 3.29.0
• Quarkus update recipes to upgrade your application to 3.29.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_2_0

• Quarkus Updates Aggregate 3.2.0
• Quarkus update recipes to upgrade your application to 3.2.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_30_0

• Quarkus Updates Aggregate 3.30.0
• Quarkus update recipes to upgrade your application to 3.30.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_31_0

• Quarkus Updates Aggregate 3.31.0
• Quarkus update recipes to upgrade your application to 3.31.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_32_0

• Quarkus Updates Aggregate 3.32.0
• Quarkus update recipes to upgrade your application to 3.32.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_33_0

• Quarkus Updates Aggregate 3.33.0
• Quarkus update recipes to upgrade your application to 3.33.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_33_1

• Quarkus Updates Aggregate 3.33.1
• Quarkus update recipes to upgrade your application to 3.33.1.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_37_0

• Quarkus Updates Aggregate 3.37.0
• Quarkus update recipes to upgrade your application to 3.37.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_38_0

• Quarkus Updates Aggregate 3.38.0
• Quarkus update recipes to upgrade your application to 3.38.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_39_0

• Quarkus Updates Aggregate 3.39.0
• Quarkus update recipes to upgrade your application to 3.39.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_3_0

• Quarkus Updates Aggregate 3.3.0
• Quarkus update recipes to upgrade your application to 3.3.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_5_0

• Quarkus Updates Aggregate 3.5.0
• Quarkus update recipes to upgrade your application to 3.5.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_6_0

• Quarkus Updates Aggregate 3.6.0
• Quarkus update recipes to upgrade your application to 3.6.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_7_0

• Quarkus Updates Aggregate 3.7.0
• Quarkus update recipes to upgrade your application to 3.7.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_8_0

• Quarkus Updates Aggregate 3.8.0
• Quarkus update recipes to upgrade your application to 3.8.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_8_3

• Quarkus Updates Aggregate 3.8.3
• Quarkus update recipes to upgrade your application to 3.8.3.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

org.openrewrite.quarkus.MigrateToQuarkus_v3_9_0

• Quarkus Updates Aggregate 3.9.0
• Quarkus update recipes to upgrade your application to 3.9.0.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

sh.stubborn.contract.migration.MigrateFromSpringCloudContract

• Migrate from Spring Cloud Contract to Stubborn Contract
• Composite recipe that updates Maven/Gradle coordinates, Java package names, and drops JUnit 4 StubRunner / Verifier usage. Run this after adding stubborn-contract-migration to your build's rewrite plugin configuration.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.

sh.stubborn.contract.migration.UpdateDependencies

• Update Spring Cloud Contract coordinates to Stubborn Contract
• Replaces org.springframework.cloud:spring-cloud-contract-* GAVs with sh.stubborn:stubborn-* equivalents, migrates the spring-cloud-contract-dependencies BOM, and swaps both build plugins, in Maven and Gradle builds alike. The com.toomuchcoding JSON/XML assertion coordinates are swapped alongside the sh.stubborn.jsonassert / sh.stubborn.xmlassert package renames. Every coordinate is repinned to latest.release.

Data tables:

• org.openrewrite.maven.table.MavenMetadataFailures: Attempts to resolve maven metadata that failed.