Build Items

No Javadoc found

The configuration type build item. Every configuration type should be registered using this build item to ensure that the converter is properly loaded in the native image case.

No Javadoc found

No Javadoc found

No Javadoc found

No Javadoc found

Way for maven and gradle plugins to discover if any declared extensions support quarkus deploy

No Javadoc found

An additional configuration property to set when a dev service sets another, specific configuration property. Quarkus will make sure the relevant settings are present in both JVM and native modes. This is used to change the defaults of extension configuration when dev services are in use, for example to enable schema management in the Hibernate ORM extension.

BuildItem for running dev services. Combines injected configs to the application with container id (if it exists). Processors are expected to return this build item not only when the dev service first starts, but also if a running dev service already exists. RunningDevService helps to manage the lifecycle of the running dev service.

Allows disabling of instrumentation based reload if the changed class matches certain criteria

No Javadoc found

Allows for a handler to be registered when exceptions are logged. This is intended for use in dev/test mode to allow Quarkus to help the developer handle the issue.

Build item that defines dependencies that should not be indexed. This can be used when a dependency contains a marker file (e.g. META-INF/beans.xml).

The main executor for blocking tasks.

Represents functionality provided by an extension. The name of the feature gets displayed in the log during application bootstrap. An extension should provide at most one feature. The name must be unique. If multiple extensions register a feature of the same name the build fails. The name of the feature should only contain lowercase characters, words are separated by dash - ; e.g. security-jpa . Features provided by core extensions should be listed in the Feature enum.

No Javadoc found

Marker used only to ensure that the file system resources where properly written in dev mode.

No Javadoc found

A build item that provides the ability to detect if the current thread is an IO thread

Represents an initialization task for the application. Often extensions perform some sort of initialization as part of the application startup. There are cases where we want to externalize the initialization (e.g. in a pipeline). Often the task is run using the same artifact as the application but using a different command or arguments. In the later case it might be desirable to pass additional environment variables to both the init tasks (to enable init) and the application (to disable the init).

If present, will force the addition of the -H:+InlineBeforeAnalysis flag during native image build

No Javadoc found

No Javadoc found

JNI access registration fine-grained to single fields for a given class.

Used to register a lambda capturing type in native mode

A build item that can be used to query the live reload state. It can also be used to store context information that is persistent between hot reloads.

No Javadoc found

The log console format build item. Producing this item will cause the logging subsystem to disregard its console logging formatting configuration and use the formatter provided instead. If multiple formatters are enabled at run time, a warning message is printed and only one is used.

A build item for adding additional logging handlers.

No Javadoc found

Contains information to decorate the Log output. Can be used by extensions that output the log / stacktraces, for example the error page. Also see io.quarkus.runtime.logging.DecorateStackUtil to assist with the decoration

No Javadoc found

No Javadoc found

A build item for adding additional named logging handlers.

Do not use directly: use io.quarkus.deployment.builditem.nativeimage.NativeImageAllowIncompleteClasspathBuildItem instead.

No Javadoc found

Represents a GraalVM Feature to be passed to native-image through the --features options.

A build item that indicates that a static resource should be included in the native image. A static resource is a file that is not processed by the build steps, but is included in the native image as-is. The resource path passed to the constructor is a / -separated path name (with the same semantics as the parameters) passed to java.lang.ClassLoader#getResources(String) . Related build items:

A build item that indicates that directory resources should be included in the native image Related build items:

The resolved factory for the native image runner. Warning: This build item should not be consumed without the use of io.quarkus.deployment.pkg.steps.NativeOrNativeSourcesBuild in the onlyIf method of io.quarkus.builder.BuildStep because that leads to Quarkus having to resolve the container image runtime unnecessarily.

A jar that is build to run the native image

A build item that indicates the minimal acceptable JDK version the native-image tool was bundled with.

Used to capture object substitution information for non-serializable classes.

No Javadoc found

Extension build steps can produce this if preloading classes is enabled.

No Javadoc found

A build item that represents the raw command line arguments as they were passed to the application. This can be passed directly to bytecode recorders that take a Supplier<String[]> . No filtering is done on these parameters.

Used to register a class for reflection in native mode

Used by io.quarkus.deployment.steps.ReflectiveHierarchyStep to determine whether the final fields of the class should be writable (which they aren’t by default) If any one of the predicates returns true for a class, then ReflectiveHierarchyStep uses that true value

Attempts to register a complete type hierarchy for reflection. This is intended to be used to register types that are going to be serialized, e.g. by Jackson or some other JSON mapper. This will do 'smart discovery' and in addition to registering the type itself it will also attempt to register the following: - Superclasses - Subclasses - Component types of collections - Types used in bean properties (if method reflection is enabled) - Field types (if field reflection is enabled) This discovery is applied recursively, so any additional types that are registered will also have their dependencies discovered

No Javadoc found

No Javadoc found

Provides a way to register a io.quarkus.runtime.configuration.ConfigBuilder in RUNTIME.

A build item that carries all the "fake" run time config objects for use by recorders.

Marker used by Build Steps that consume runtime configuration to ensure that they run after the runtime config has been set up.

A package that will be initialized at runtime in native mode. WARNING: this build item should not be used in Quarkus itself and is only provided to simplify the early stages of external extensions development. For Quarkus development, please take the time to surgically mark individual classes as runtime initialized.

Aggregates SBOMs generated for packaged applications. The API around this is still in development and will likely change in the near future.

A symbolic class that represents a service start. StartupEvent is fired after all services are started.

No Javadoc found

Marker item to specify that SnapStart is enabled.

No Javadoc found

A build item for adding the dev stream log via mutiny.

Represents a system property that will be set immediately on application startup.

This is an optional build item that allows us to track additional test classes that will become beans. It is only available during tests.

No Javadoc found

Virtual build item that is used to signify that a step must be run to set up continuous testing

The results of applying bytecode transformation to a class. Note that this has also been abused somewhat to also represent removed resources, as the logic is the same, and it avoids having two separate mechanisms that essentially do the same thing.

Merge duplicate resources from multiple JARs when building an Uber Jar

Native-image might not be supported for a particular extension on a given OS or architecture.

A build item for JDBC datasources. If you inject this build item when recording runtime init template calls, you are guaranteed the datasources configuration has been injected and datasources can be created.

Register a JDBC driver for the Agroal extension. It allows to resolve automatically the driver from the kind, thus users don’t have to set the driver anymore, except if they want to use a specific one.

Marker build item that indicates that the OpenTelemetry extension has been initialized.

No Javadoc found

Handler provided by another extension i.e. AWS Lambda HTTP

Make it possible to add, remove or alter annotations on various components. The provided transformer uses AnnotationsTransformer#appliesTo(AnnotationTarget.Kind) to limit the scope of transformer to classes, fields, methods, method params or a combination of those. These metadata changes are not stored in Jandex directly (Jandex is immutable) but instead in an abstraction layer. Users/extensions can access io.quarkus.arc.processor.AnnotationStore to view the updated annotation model. NOTE: Extensions that operate purely on Jandex index analysis won’t be able to see any changes made via AnnotationsTransformer !

This build item can be used to turn a class that is not annotated with a CDI scope annotation into a bean, i.e. the default scope annotation is added automatically if all conditions are met.

Represent a Jandex IndexView on the whole deployment that has a complete CDI-related information. As such, this index should be used for any CDI-oriented work. Compared to io.quarkus.deployment.builditem.CombinedIndexBuildItem this index can contain additional classes that were indexed while bean discovery was in progress. @see GeneratedBeanBuildItem @see io.quarkus.deployment.builditem.CombinedIndexBuildItem

A build item that represents the fully initialized CDI bean container. This item is produced as the last step of the ArC bootstrap process.

This build item is used to specify additional bean defining annotations. See also 2.5.1. Bean defining annotations. By default, the resulting beans must not be removed even if they are considered unused and ArcConfig#removeUnusedBeans is enabled.

Bean registration phase can be used to register synthetic beans. An extension that needs to produce other build items during the "bean registration" phase should use this build item. The build step should produce a BeanConfiguratorBuildItem or at least inject a BuildProducer for this build item, otherwise it could be ignored or processed at the wrong time, e.g. after ArcProcessor#validate(BeanRegistrationPhaseBuildItem,List,BuildProducer) . @see BeanConfiguratorBuildItem @see BeanRegistrar

A type of build item that contains only declaring classes, methods and fields that have been annotated with unsuccessful build time conditions. It aims to be used to manage the exclusion of the annotations thanks to the build time conditions also known as IfBuildProfile , UnlessBuildProfile , IfBuildProperty and UnlessBuildProperty @see io.quarkus.arc.deployment.PreAdditionalBeanBuildTimeConditionBuildItem @see io.quarkus.arc.profile.IfBuildProfile @see io.quarkus.arc.profile.UnlessBuildProfile @see io.quarkus.arc.properties.IfBuildProperty @see io.quarkus.arc.properties.UnlessBuildProperty

This build item hold the "final" predicate that is used to distinguish application classes from framework/library classes.

Context registration phase can be used to register custom CDI contexts. An extension that needs to produce other build items during the "context registration" phase should use this build item. The build step should produce a ContextConfiguratorBuildItem or at least inject a BuildProducer for this build item, otherwise it could be ignored or processed at the wrong time, e.g. after ArcProcessor#registerBeans(ContextRegistrationPhaseBuildItem,List,BuildProducer,BuildProducer,BuildProducer) . Typical workflow involves obtaining a ContextConfigurator via getContext().configure() . Note that there is no need to invoke ContextConfigurator#done() once you are done as it is performed automatically. @see ContextConfiguratorBuildItem @see CustomScopeBuildItem

Holds information about all known custom scopes in the deployment and has utility methods allowing to check whether given class has some scope annotation.

This build item is used to specify types to be excluded from discovery. An element value can be:

If any element value matches a discovered type then the type is excluded from discovery, i.e. no beans and observer methods are created from this type.

Allows extensions to programmatically exclude certain packages from split package detection which is executed by SplitPackageProcessor . Extensions are encouraged to solve split package issues and this build item should be used primarily as temporary workaround. A package string representation can be:

Represents an intercepted static method.

Makes it possible to register annotations that should be considered interceptor bindings but are not annotated with jakarta.interceptor.InterceptorBinding .

Provides access to InvokerFactory . May only be used in the bean registration phase, observer registration phase, and validation phase (basically, until ArC generates the classes). Afterwards, any attempt to call #createInvoker(BeanInfo,MethodInfo) throws an exception.

An extension that needs to produce other build items during the "synthetic observer registration" phase should use this build item. The build step should produce a ObserverConfiguratorBuildItem or at least inject a BuildProducer for this build item, otherwise it could be ignored or processed at the wrong time, e.g. after ArcProcessor#validate(ObserverRegistrationPhaseBuildItem,List) . @see ObserverConfiguratorBuildItem @see ObserverRegistrar

A build item that represents the fully initialized CDI bean container. This item is produced immediately before BeanContainerBuildItem in order to give recorders the chance to do something immediately before real recording steps come into play.

This build item instructs ArC to produce a ReflectiveClassBuildItem for a client proxy and intercepted subclass generated for the given bean class.

This build item is used to specify resource annotations that makes it possible to resolve non-CDI injection points, such as Java EE resources.

Consumers of this build item can easily inspect all beans, observers and injection points registered in the application. Synthetic beans and observers are included. If interested in class-based components only you can use the BeanDiscoveryFinishedBuildItem instead. Additionally, the bean resolver can be used to apply the type-safe resolution rules, e.g. to find out whether there is a bean that would satisfy certain combination of required type and qualifiers. @see BeanDiscoveryFinishedBuildItem

This build item should be consumed by build steps that require RUNTIME_INIT synthetic beans to be initialized. @see SyntheticBeanBuildItem

This build item is used to exclude beans that would be normally removed if the config property ArcConfig#removeUnusedBeans is set to true. Consider using one of the convenient static factory methods such as #beanTypes(Class…​) : ` @BuildStep UnremovableBeanBuildItem unremovable() { // Any bean that has MyService in its set of bean types is considered unremovable return UnremovableBeanBuildItem.beanTypes(MyService.class); }

No Javadoc found

This build item is used to pass the full list of cache names from the validation step to the recording step.

A build item that makes sure a CacheManagerInfo is available at runtime for consideration as the cache backend

No Javadoc found

No Javadoc found

This BuildItem can be used to override the default image name. It can be used in cases where the name of the image is customized externally. Example: The openshift extension may override the name. To ensure that things are in sync with the image name needs to be set.

A label to be added to the built container image This will only have an effect if the extension building the container image supports adding custom labels (like the Jib extension)

No Javadoc found

A build item that represents the "quarkus.datasource.db-kind" value. This is generated by specific extensions that are meant to take away the burden of configuring anything datasource related from the user.

A provider that knows how to start a database of a specific type.

Extensions should produce this build item if a DEV UI card with the Keycloak Admin link should be created for the extension.

A marker build item signifying that integrating extensions (like OIDC and OIDC client) are enabled. The Keycloak Dev Service will be started in DEV mode if at least one item is produced and the Dev Service is not disabled in other fashion.

No Javadoc found

This represents a {@linkplain SecurityDomain} instance output by a build step.

No Javadoc found

No Javadoc found

No Javadoc found

No Javadoc found

Quarkus attempts to automatically define a persistence unit when the Hibernate ORM extension is enabled, a default datasource is defined, and there are mapped entities. This build item represents the decision about creating such an implied persistence unit; it’s modelled as a BuildItem so that other extensions can be aware of such a persistence unit being defined (e.g. Hibernate Reactive needs to know).

Provides the Jandex index of the application, combined with the index of additional JPA components that might have been generated. @author Sanne Grinovero <sanne@hibernate.org>

Internal model to hold the mapping linking a JPA entity to its corresponding persistence units.