feat(camunda 7.20): updated JDK 17, Spring boot 3.1.3, Camunda BPM Da…

.github/workflows/development.yml

@@ -7,7 +7,7 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    name: Build and run tests on JDK 11
+    name: Build and run tests on JDK 17
     steps:
       # Checkout the code
       - name: Checkout code
@@ -17,10 +17,10 @@ jobs:
         run: echo ${{ github.ref }}
 
       # Setup JDK and Maven
-      - name: Set up JDK 11
+      - name: Set up JDK 17
         uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
           cache: maven
           distribution: 'zulu'
           server-id: ossrh

.github/workflows/master.yml

@@ -18,10 +18,10 @@ jobs:
         run: echo ${{ github.ref }}
 
       # Setup JDK and Maven
-      - name: Set up JDK 11
+      - name: Set up JDK 17
         uses: actions/setup-java@v3
         with:
-          java-version: 11
+          java-version: 17
           cache: maven
           distribution: 'zulu'
           server-id: ossrh

.java-version

@@ -1 +1 @@
-11.0
+17.0

example/fixture/src/main/kotlin/infrastructure/adapter/rest/approve/ApproveOrderController.kt

@@ -7,7 +7,7 @@ import io.holunda.camunda.worker.example.infrastructure.adapter.rest.toDto
 import org.springframework.http.ResponseEntity
 import org.springframework.http.ResponseEntity.*
 import org.springframework.web.bind.annotation.*
-import javax.validation.Valid
+import jakarta.validation.Valid
 
 /**
  * Rest controller to access the "approve order" use case.

example/fixture/src/main/kotlin/infrastructure/adapter/workflow/LoadOrderWorker.kt

@@ -31,7 +31,11 @@ class LoadOrderWorker(
 
     writer
       .set(ORDER_TOTAL, total)
-      .set(ORDER, order)
+      .apply {
+        if (order != null) {
+          this.set(ORDER, order)
+        }
+      }
 
     logger.info { "[LOAD ORDER]: Finished order loading, order is: $order, total is set to $total" }
   }

extension/camunda-7/src/main/kotlin/impl/CamundaWorker7Properties.kt

@@ -1,14 +1,11 @@
 package io.holunda.camunda.worker.impl
 
 import org.springframework.boot.context.properties.ConfigurationProperties
-import org.springframework.boot.context.properties.ConstructorBinding
 
 /**
  * Properties to set up the Camunda 7 operation mode.
  */
 @ConfigurationProperties("camunda.bpm.worker")
-@ConstructorBinding
 data class CamundaWorker7Properties(
   val taskMode: ExternalTaskMode
 )
-

extension/camunda-8/src/main/kotlin/impl/Camunda8ZeebeWorkerConfiguration.kt

@@ -3,12 +3,9 @@ package io.holunda.camunda.worker.impl
 import com.fasterxml.jackson.databind.ObjectMapper
 import io.camunda.zeebe.client.ZeebeClient
 import io.camunda.zeebe.spring.client.exception.ZeebeBpmnError
-import io.holunda.camunda.worker.ProcessStarter
 import io.holunda.camunda.worker.ServiceTaskBpmnError
 import org.camunda.bpm.engine.variable.Variables
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
 import org.springframework.boot.context.event.ApplicationReadyEvent
-import org.springframework.context.annotation.Bean
 import org.springframework.context.event.EventListener
 import java.util.*
 
@@ -57,4 +54,4 @@ class Camunda8ZeebeWorkerConfiguration(
         .open()
     }
   }
-}
+}

extension/camunda-8/src/main/kotlin/impl/MapReader.kt

@@ -5,8 +5,6 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import io.holunda.camunda.bpm.data.factory.*
 import io.holunda.camunda.bpm.data.reader.VariableReader
 import java.math.BigDecimal
-import java.time.Instant
-import java.time.OffsetDateTime
 import java.time.temporal.Temporal
 import java.util.*
 
@@ -17,7 +15,7 @@ class MapReader(
   private val delegateLocalToGlobal: Boolean = true
 ) : VariableReader {
 
-  override fun <T : Any> getOptional(variableFactory: VariableFactory<T>): Optional<T> {
+  override fun <T> getOptional(variableFactory: VariableFactory<T>): Optional<T> {
     return Optional.ofNullable(
       if (json.containsKey(variableFactory.name)) {
         val variableNode = json[variableFactory.name]
@@ -30,20 +28,20 @@ class MapReader(
       } else {
         null
       }
-    )
+    ) as Optional<T>
   }
 
-  override fun <T : Any> get(variableFactory: VariableFactory<T>): T {
+  override fun <T> get(variableFactory: VariableFactory<T>): T {
     return getOptional(variableFactory).get()
   }
 
-  override fun <T : Any> getLocal(variableFactory: VariableFactory<T>): T {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> getLocal(variableFactory: VariableFactory<T>): T {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     return getOptional(variableFactory).get()
   }
 
-  override fun <T : Any> getLocalOptional(variableFactory: VariableFactory<T>): Optional<T> {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> getLocalOptional(variableFactory: VariableFactory<T>): Optional<T> {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     return getOptional(variableFactory)
   }
 
@@ -60,7 +58,7 @@ class MapReader(
   /**
    * Is composite?
    */
-  private fun <T : Any> VariableFactory<T>.isComposite() =
+  private fun <T> VariableFactory<T>.isComposite() =
     this is BasicVariableFactory
       && !this.variableClass.isPrimitive // not a primitive (int, long, float, bool)
       && !this.variableClass.isAssignableFrom(String::class.java)

extension/camunda-8/src/main/kotlin/impl/MapWriter.kt

@@ -14,67 +14,67 @@ class MapWriter(
 
   private val writer = CamundaBpmData.writer(result)
 
-  override fun <T : Any?> setLocal(variableFactory: VariableFactory<T>?, value: T): MapWriter {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> setLocal(variableFactory: VariableFactory<T>, value: T): MapWriter {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     writer.set(variableFactory, value)
     return this
   }
 
-  override fun <T : Any?> setLocal(variableFactory: VariableFactory<T>?, value: T, isTransient: Boolean): MapWriter {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> setLocal(variableFactory: VariableFactory<T>, value: T, isTransient: Boolean): MapWriter {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     writer.set(variableFactory, value, isTransient)
     return this
   }
 
-  override fun <T : Any?> updateLocal(variableFactory: VariableFactory<T>?, valueProcessor: Function<T, T>?): MapWriter {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> updateLocal(variableFactory: VariableFactory<T>, valueProcessor: Function<T, T>): MapWriter {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     writer.update(variableFactory, valueProcessor)
     return this
   }
 
-  override fun <T : Any?> updateLocal(variableFactory: VariableFactory<T>?, valueProcessor: Function<T, T>?, isTransient: Boolean): MapWriter {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> updateLocal(variableFactory: VariableFactory<T>, valueProcessor: Function<T, T>, isTransient: Boolean): MapWriter {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     writer.update(variableFactory, valueProcessor, isTransient)
     return this
   }
 
-  override fun <T : Any?> removeLocal(variableFactory: VariableFactory<T>?): MapWriter {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+  override fun <T> removeLocal(variableFactory: VariableFactory<T>): MapWriter {
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     writer.remove(variableFactory)
     return this
   }
 
   override fun variablesLocal(): VariableMap {
-    require(delegateLocalToGlobal) { "Access to local variables is not supported."}
+    require(delegateLocalToGlobal) { "Access to local variables is not supported." }
     return writer.variables()
   }
 
-  override fun <T : Any?> set(variableFactory: VariableFactory<T>?, value: T): MapWriter {
+  override fun <T> set(variableFactory: VariableFactory<T>, value: T): MapWriter {
     writer.set(variableFactory, value)
     return this
   }
 
-  override fun <T : Any?> set(variableFactory: VariableFactory<T>?, value: T, isTransient: Boolean): MapWriter {
+  override fun <T> set(variableFactory: VariableFactory<T>, value: T, isTransient: Boolean): MapWriter {
     writer.set(variableFactory, value, isTransient)
     return this
   }
 
-  override fun <T : Any?> update(variableFactory: VariableFactory<T>?, valueProcessor: Function<T, T>?): MapWriter {
+  override fun <T> update(variableFactory: VariableFactory<T>, valueProcessor: Function<T, T>): MapWriter {
     writer.update(variableFactory, valueProcessor)
     return this
   }
 
-  override fun <T : Any?> update(variableFactory: VariableFactory<T>?, valueProcessor: Function<T, T>?, isTransient: Boolean): MapWriter {
+  override fun <T> update(variableFactory: VariableFactory<T>, valueProcessor: Function<T, T>, isTransient: Boolean): MapWriter {
     writer.update(variableFactory, valueProcessor, isTransient)
     return this
   }
 
-  override fun <T : Any?> remove(variableFactory: VariableFactory<T>?): MapWriter {
+  override fun <T> remove(variableFactory: VariableFactory<T>): MapWriter {
     writer.remove(variableFactory)
     return this
   }
 
   override fun variables(): VariableMap {
     return writer.variables()
   }
-}
+}

pom.xml

@@ -15,11 +15,11 @@
     <project.build.sourceEncoding>${project.encoding}</project.build.sourceEncoding>
     <project.reporting.outputEncoding>${project.encoding}</project.reporting.outputEncoding>
 
-    <java.version>11</java.version>
-    <kotlin.version>1.8.10</kotlin.version>
-    <spring-boot.version>2.7.7</spring-boot.version>
-    <springdoc.version>1.6.14</springdoc.version>
-    <camunda-bpm-data.version>1.2.8</camunda-bpm-data.version>
+    <java.version>17</java.version>
+    <kotlin.version>1.9.10</kotlin.version>
+    <spring-boot.version>3.1.3</spring-boot.version>
+    <springdoc.version>1.7.0</springdoc.version>
+    <camunda-bpm-data.version>1.4.0</camunda-bpm-data.version>
 
     <!-- TEST -->
     <kotlin-logging.version>3.0.0</kotlin-logging.version>
@@ -344,7 +344,7 @@
             </execution>
           </executions>
           <configuration>
-            <jdkVersion>11</jdkVersion>
+            <jdkVersion>17</jdkVersion>
             <!--
             <includes>
               <include>packages.md</include>
@@ -512,7 +512,7 @@
               <configuration>
                 <rules>
                   <requireJavaVersion>
-                    <version>11</version>
+                    <version>17</version>
                   </requireJavaVersion>
                   <requireMavenVersion>
                     <version>3.6.0</version>