Flowable 6.8.1 release

• This is a bug fix release.
• Added async leave functionality to support leaving an activity with an async job.
• Added support to listen to a variable event in multiple variable elements in BPMN and CMMN.
• Added support for String collection and JSON array for mail recipients in the mail task.
• Added an option to not create a repetition counter variable for repetition elements in CMMN.
• Fixed issue with event subscriptions triggering a plan item instance in an unavailable state.
• Added support for LocalDate and LocalDateTime for timer expressions in BPMN and CMMN.
• Added support for adding and removing waiting for repetition in the case instance migration and change state API.
• Added support for mapping plan item ids to a different value in the case instance migration.
• Fixed issue with sentry part instances being in an incorrect state after case instance migration.
• Fixed issue with incorrect stages getting activated on case instance migration.
• Added support for adding repetition when reactivating a case instance.
• Added support for batch case instance migration to the CMMN engine.
• Added support to stop a housekeeping batch.
• Improved history cleaning to limit the amount of sub process instances in one bulk delete.
• Upgrade to Spring Boot 2.7.18

Flowable 7.0.1 release

• This is a minor release including support for Spring Boot 3.1.6.
• Add support to dynamically create an event subscription to start a case or process instance.
• Add support to register a filter class in the inbound channel pipeline that is invoked for all events that are being received through that channel.
• Added an option to query for parent and root scope ids for (historic) case, process and task instances.
• Added an option to not create a repetition counter variable for repetition elements in CMMN.
• Fixed issue with incorrect stages getting activated on case instance migration.

Flowable 7.0.0 release

• This is the first stable release for version 7 of the Flowable Engines focusing on the Spring Boot 3, Spring 6 and Java 17 upgrade.
• The REST application requires a servlet container / application server that supports Jakarta 9.
• This release focuses on the main Flowable Engines and REST APIs for the BPMN, CMMN, DMN and event registry engines. This means that there are no UI applications, no content and form engines and the modules for Mule and some others are removed.
• Blog post with more information about the Flowable 7 release https://www.flowable.com/blog/engineering/flowable-open-source-7-0-0-release
• Support batch migration for CMMN
• Repetition support for case reactivation
• Support for stopping housekeeping batch
• Support for HTTP HEAD and OPTIONS for the Http Tasks
• Remove relocated Spring Boot Starters
  • flowable-spring-boot-starter-basic - flowable-spring-boot-starter-process should be used instead
  • flowable-spring-boot-starter-rest-api - flowable-spring-boot-starter-process-rest should be used instead
• Add flowable-bom with all the Flowable artifacts
• Support for dynamic Kafka message key
• Add TaskCompletionBuilder to CmmnTaskService
• Add support for handling custom input parameters for error start and boundary events and for passing additional data in error end events
• Add ability to store completer of human and user tasks in a variable
• Support collection of string or json array as mail recipients in Mail Tasks
• Upgrade to Spring Boot 3.1
• Upgrade to Camel 4
• Upgrade to CXF 4
• Provide an abstraction for sending emails through a FlowableMailClient
• Use Jakarta Mail instead of Javax Mail and replace Apache Commons Email with Eclipse Angus Mail
• Remove message based executor
• Remove some Flowable deprecated code
  • CmmnRepositoryService#getDecisionTablesForCaseDefinition - use CmmnRepositoryService#getDecisionsForCaseDefinition instead
  • RepositoryService#getDecisionTablesForProcessDefinition - use RepositoryService#getDecisionsForProcessDefinition instead
  • HistoricCaseInstanceQuery#limitCaseVariables - no replacement it was a noop
  • CaseInstanceQuery#limitCaseInstanceVariables - no replacement it was a noop
  • HistoricProcessInstanceQuery#limitProcessInstanceVariables - no replacement it was a noop
  • ProcessInstanceQuery#limitProcessInstanceVariables - no replacement it was a noop
  • TaskInfoQuery#limitTaskVariables - no replacement it was a noop
  • Removed query limit configurations from CmmnEngineConfiguration and ProcessEngineConfigurationImpl
  • Removed HistoryManager#recordActivityEnd - no replacement, Flowable was never calling that method
  • Removed org.flowable.engine.FlowableTaskAlreadyClaimedException - use org.flowable.common.engine.api.FlowableTaskAlreadyClaimedException instead
  • Removed org.flowable.engine.cfg.MailServerInfo - use org.flowable.common.engine.impl.cfg.mail.MailServerInfo instead
  • Removed org.flowable.http.HttpRequest - use org.flowable.http.common.api.HttpRequest instead
  • Removed org.flowable.http.HttpResponse - use org.flowable.http.common.api.HttpResponse instead
  • Removed org.flowable.http.delegate.HttpRequestHandler - use org.flowable.http.common.api.delegate.HttpRequest instead
  • Removed org.flowable.http.delegate.HttpResponseHandler - use org.flowable.http.common.api.delegate.HttpResponse instead
  • Removed org.flowable.identitylink.service.IdentityLinkType - use org.flowable.identitylink.api.IdentityLinkType instead
  • Removed ManagedAsyncJobExecutor - configure the thread factory in the engine configuration
  • Removed org.flowable.spring.SpringCallerRunsRejectedJobsHandler - use org.flowable.spring.job.service.SpringCallerRunsRejectedJobsHandler instead
  • Removed org.flowable.spring.SpringRejectedJobsHandler - use org.flowable.spring.job.service.SpringRejectedJobsHandler instead
• Remove async history support. In case you were using async history, make sure that you have no async history jobs before starting the new version

Flowable 7.0.0.M2 release

• Support batch migration for CMMN
• Repetition support for case reactivation
• Support for stopping housekeeping batch
• Support for HTTP HEAD and OPTIONS for the Http Tasks
• Remove relocated Spring Boot Starters
  • flowable-spring-boot-starter-basic - flowable-spring-boot-starter-process should be used instead
  • flowable-spring-boot-starter-rest-api - flowable-spring-boot-starter-process-rest should be used instead
• Add flowable-bom with all the Flowable artifacts
• Support for dynamic Kafka message key
• Add TaskCompletionBuilder to CmmnTaskService
• Add support for handling custom input parameters for error start and boundary events and for passing additional data in error end events
• Add ability to store completer of human and user tasks in a variable
• Support collection of string or json array as mail recipients in Mail Tasks
• Upgrade to Spring Boot 3.1
• Upgrade to Camel 4
• Upgrade to CXF 4
• Provide an abstraction for sending emails through a FlowableMailClient
• Use Jakarta Mail instead of Javax Mail and replace Apache Commons Email with Eclipse Angus Mail
• Remove message based executor
• Remove some Flowable deprecated code
  • CmmnRepositoryService#getDecisionTablesForCaseDefinition - use CmmnRepositoryService#getDecisionsForCaseDefinition instead
  • RepositoryService#getDecisionTablesForProcessDefinition - use RepositoryService#getDecisionsForProcessDefinition instead
  • HistoricCaseInstanceQuery#limitCaseVariables - no replacement it was a noop
  • CaseInstanceQuery#limitCaseInstanceVariables - no replacement it was a noop
  • HistoricProcessInstanceQuery#limitProcessInstanceVariables - no replacement it was a noop
  • ProcessInstanceQuery#limitProcessInstanceVariables - no replacement it was a noop
  • TaskInfoQuery#limitTaskVariables - no replacement it was a noop
  • Removed query limit configurations from CmmnEngineConfiguration and ProcessEngineConfigurationImpl
  • Removed HistoryManager#recordActivityEnd - no replacement, Flowable was never calling that method
  • Removed org.flowable.engine.FlowableTaskAlreadyClaimedException - use org.flowable.common.engine.api.FlowableTaskAlreadyClaimedException instead
  • Removed org.flowable.engine.cfg.MailServerInfo - use org.flowable.common.engine.impl.cfg.mail.MailServerInfo instead
  • Removed org.flowable.http.HttpRequest - use org.flowable.http.common.api.HttpRequest instead
  • Removed org.flowable.http.HttpResponse - use org.flowable.http.common.api.HttpResponse instead
  • Removed org.flowable.http.delegate.HttpRequestHandler - use org.flowable.http.common.api.delegate.HttpRequest instead
  • Removed org.flowable.http.delegate.HttpResponseHandler - use org.flowable.http.common.api.delegate.HttpResponse instead
  • Removed org.flowable.identitylink.service.IdentityLinkType - use org.flowable.identitylink.api.IdentityLinkType instead
  • Removed ManagedAsyncJobExecutor - configure the thread factory in the engine configuration
  • Removed org.flowable.spring.SpringCallerRunsRejectedJobsHandler - use org.flowable.spring.job.service.SpringCallerRunsRejectedJobsHandler instead
  • Removed org.flowable.spring.SpringRejectedJobsHandler - use org.flowable.spring.job.service.SpringRejectedJobsHandler instead
• Remove async history support. In case you were using async history, make sure that you have no async history jobs before starting the new version

Flowable 7.0.0.M1 release

• This is the first milestone for version 7 of the Flowable Engines focusing on the Spring Boot 3, Spring 6 and Java 17 upgrade.
• The plan forward is to keep maintaining the 6.x and 7.x versions for at least the next year, so we will do both 6.x and 7.x releases.
• The REST application requires a servlet container / application server that supports Jakarta 9.
• This release focuses on the main Flowable Engines and REST APIs for the BPMN, CMMN, DMN and event registry engines. This means that there are no UI applications, no content and form engines and the modules for Mule and some others are removed.

Flowable 6.8.0 release

• Added support for using scripts in task and execution listeners and HTTP request and response handlers.
• Added support for new task and instance history levels to provide more options to reduce the amount of historic data stored.
• Added support to throw BPMN errors in scripts.
• Added support for headers in an event model that can be used with event registry events in case and process definitions.
• Improved support for starting case and process instances with the unique feature enabled on event registry start events.
  The event subscription for the event registry event is locked while starting the case and process instance to prevent any duplicate instances.
• Added support for async leave in addition to the already long existing async (before) attribute for async tasks in BPMN and CMMN.
  An async job will be created to execute the leave of a task when the async leave attribute is set to true.
• Improved support for parallel repeatable event listeners in case definitions.
• Added interface to provide an implementation for non-matching events that are received in the event registry.
• Added support to query directly on runtime variable instances both in the Java API and REST API.
• Improved housekeeping logic to reduce the throughput time.
• Added support for retries in Kafka channels in the event registry.
• Expose topic, partitions and offset consumer record for inbound Kafka channel and provide custom partition support for outbound Kafka channel.
• Added bulk support for deleting case and process instances, terminating case instances and moving deadletter jobs to executable.
• Added activity instance REST API query support.
• Fixed issue with event listeners in a repeatable stage in a case definition.
• Fixed issue with having multiple event registry start events in a process definition.
• Add dedicated task executor for the task invoker. This is fixing an issue with a potential deadlock when using the "true parallel" HTTP task feature.
• Improved channel definition caching logic to prevent channels from getting unregistered when they should not.
• Added support for providing an owner and assignee when starting a case or process instance.
• Upgrade to Spring Boot 2.7.6.

Flowable 6.7.2 release

• Fixed issue with vulnerable Log4j dependency. The Flowable apps now use the default Spring Boot logging framework, which is Logback.
• Added support to execute a decision service in the DMN REST API.
• Added support to query tasks with case instance variables.
• Fixed issue with migrating a process instance to a new process definition with a call activity and a new boundary event.
• Upgraded to Spring boot 2.6.2.

Flowable 6.7.1 release

• A case and process instance has support for a business status value, similar to a business key.
• Added support for deleting historic case and process instances and their related data using batches and batch parts.
• Fixed issue with the global lock mechanism when running a cluster of Flowable instances.
• Fixed issue with transient variables made persistent when passing all variables to a sub process instance with a call activity task.
• Added support for querying tasks, jobs and event subscriptions without the BPMN or CMMN entities. By using withoutProcessInstanceId on the task query for example you can make sure that only CMMN tasks and standalone tasks are returned without the BPMN tasks.
• Added MariaDB to the Flowable QA databases in Github Actions.

Flowable 6.7.0 release

• Implemented a global locking mechanism to have better support for using the async executor in a setup with multiple Flowable Engines. Together with this the async executor default configuration was changed to be able to handle more jobs per second by default. A 4-part article series describe all the fine details and a performance benchmark of this, https://blog.flowable.org/2021/04/14/handling-asynchronous-operations-with-flowable-part-1-introducing-the-new-async-executor/,
  https://blog.flowable.org/2021/04/21/handling-asynchronous-operations-with-flowable-part-2-components-configuration/, https://blog.flowable.org/2021/04/28/handling-asynchronous-operations-with-flowable-part-3-performance-benchmarks/,
  https://blog.flowable.org/2021/05/05/handling-asynchronous-operations-with-flowable-part-4-evolution-of-the-async-executor/.
• Added support for multi instance variable aggregation, https://blog.flowable.org/2021/02/16/multi-instance-variable-aggregation/.
  Aggregating values from a multi instance execution has always been tricky, but now with the support for variable aggregation this can be handled in an elegant way.
• Added support for case reactivation to support reactivating historic and completed case instances to a running case instance. Case definitions can have a case reactivation listener. that can be triggered to reactivate a historic case instance and the variable context etc will be re-created.
• A variable listener has been added to allow for BPMN and CMMN models to listen to changes for a specific variable and handle this trigger in the model.
• Add support for repetition signal and generic event listener in the CMMN engine to be triggered in parallel.
• Added an optimization flag for asynchronous multi-instance usage when the multi-instance is an automatic step or a sequence of automatic steps. If set, the engine will drastically lower resource consumption, and remove the optimistic locking exceptions and typically be more performant.
• Added support of synchronous handling of event registry events.
• Added support for DMN 1.3 version models.
• Added support for method overloading in JUEL / backend expressions.
• Added localization support for case definitions and runtime and history case instances and plan item instances.
• Added basic CMMN model validation to the CMMN engine.
• Added basic CDI support to the CMMN engine.
• Exceptions thrown from Task listeners are no longer wrapped in FlowableException.
• Exceptions thrown from Task, case lifecycle and plan item lifecycle listeners are no longer wrapped in FlowableException.
• Improved paging of runtime and historic process and case instance queries including variables. In earlier versions queries with include variables did paging in memory with a lot of limitations. This is now done on a query level and the limitations are not present anymore.
• In this release an upgrade to Spring Boot 2.5.4 and Spring 5.3.9 was done.
• There has been a change in the way a process / case instance is started from an event from the event registry. Instead of starting the process / case asynchronously, it is started synchronously. Using this default value allows correct processing of in-order event coming on the same topic. In case in order processing is not important you can configure that as part of your model by marking the Event Registry Start event as async or marking the Case Model as async. If you want to go back to the previous default you can set the following properties: flowable.process.event-registry-start-process-instance-async and flowable.cmmn.event-registry-start-case-instance-async to true.

Flowable 6.6.0 release

GENERAL

• External worker tasks have been added to the BPMN and CMMN engine. This is a new paradigm that is available to execute service logic outside of the BPMN and CMMN engine. Until this release this could be done by pushing work to another service, like with using a HTTP task or send an event with the event registry task. The external worker task can be used to pull work from the BPMN and CMMN engine. This means that a service written in any language can pull for open external worker tasks over a dedicated external worker REST API, then execute the work, and finally complete the worker task to move the state of the process or case to the next state.
• Added support for future Java delegates to enable running service tasks and HTTP tasks actually in parallel. Until this release a parallel gateway with multiple outgoing sequence flows to a service task didn't run the synchronous service tasks really in parallel, they were still executed sequential. When these service tasks are made asynchronous and not exclusive, then they were executed in parallel by the async executor, but also in different transactions. With the new future service task support, it's now possible to run synchronous service tasks within the same transaction in parallel. The service tasks are executed in parallel on a thread pool and the future will wait until all service tasks are completed. More info is available in this https://blog.flowable.org/2020/08/06/true-parallel-service-task-execution-with-flowable/ blog post.
• Added a category property to jobs to be able to distinguish between different groups of jobs. This can also be used to enable the execution of only specific job categories in the BPMN or CMMN engine. In this way different micro services with an embedded Flowable engine using the same database can be configured to only execute jobs from a defined list of categories, as an example.
• History jobs are now moved to the deadletter job table when the retries are exhausted. This ensures that the history job is always kept in the database.
• Removed the get current engine configuration from the CommandContextUtil classes of the Flowable engines because in an application where multiple engines are used it could not be guaranteed that the correct engine configuration was returned.
• JSON variable changes are now tracked when updated in expressions, scripts, delegate classes or Spring beans. This means that when updating a property like customer.name in a delegate class, the customer JSON variable will now automatically be updated.
• Extended the entity link support to also record grand parent entity links, which means the parent process of a task in a sub process for example.
• When deploying via the BPMN, CMMN or DMN repository service the created deployment will have the parent deployment id set from its own deployment id.
• The FlowableExpressionEnhancer has been removed. We have adapted the Expression parsing, so now functions are enhanced during the expression tree building. This is a lower level api and uses the new FlowableAstFunctionCreator.

BPMN

• In and out parameters can be defined for signal events, similar to the existing in and out parameter support for call activities. By defining in parameters for a signal boundary event for example, variables can be set on the process instance scope from the signal payload data.
• Added support for triggerable service tasks with expressions.
• Added support for event registry backed receive task and intermediate catch event.
• Added support for JSON variables in web service tasks.
• For ordering activity instances that are part of the same Flowable transaction, a transaction order value has been added, which is a basic numeric value starting with 1 and incremented with 1 for every new activity instance.

CMMN

• Added support for case instance migration with defining for which plan item definitions the state needs to be changed. This also includes moving new plan item definitions to available state if needed.
• The Case task now supports in and out parameter mapping.

DMN

• Support for Decision services and DRD (Decision Requirement Diagram) has been added to the DMN engine. This enables the usage of a hierarchy of decision tables to calculate the output of a decision service in multiple decision tables.

APPS

• The UI Apps have been consolidated in one single Flowable UI App instead of 4 different applications. This makes the authentication and authorization logic less complex, makes the demo experience and installation experience easier and doesn't require you to switch between multiple browser tabs all the time. This means that now only 2 WAR files are provided in the Flowable Download, the Flowable UI app, that includes the Modeler, IDM, Admin and Task application together with the Flowable REST API and the second WAR file is the REST application that only includes the Flowable REST API. For more information you can read this https://blog.flowable.org/2020/10/07/flowable-6-instant-gratification/ blog post.
• Support for OAuth2 authentication is added to the Flowable UI App, with Keycloak as an example implementation, see also this https://blog.flowable.org/2020/10/12/whats-new-with-the-flowable-ui-apps/ blog post.
• Updated Docker images and Kubernetes Helm charts for the new Flowable UI app and with more configuration options. On the docker images the Spring boot applications are now started with a flowable user and not with the root user as before.

ADDITIONAL

• In this release an upgrade to Spring Boot 2.3.4 and Spring 5.2.9 was done.