@nanobpm/nano-ide-app-embedded-graalvm-native 1.0.3 → 1.2.0

package/nano-ide.ext.json

@@ -14,7 +14,8 @@
   "templates": [
     {
       "id": "embedded-graalvm-starter",
-      "label": "KYC microservice (GraalVM native) — same demo, ~30 MB standalone binary (ADR 0005)"
+      "label": "KYC microservice (GraalVM native)",
+      "description": "Same demo, ~30 MB standalone binary (ADR 0005)"
     }
   ],
   "toolchain": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-ide-app-embedded-graalvm-native",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "GraalVM Native Image variant of the embedded Nano JVM template: same Bernd-in-JVM code, compiled to a single standalone binary (~30 MB, no JDK required at runtime).",
   "license": "Apache-2.0",
   "keywords": [

package/templates/embedded-graalvm-starter/README.md

@@ -31,8 +31,8 @@ and run.
 
 ```sh
 ./microservice/target/kyc-microservice
-# defaults to ws://localhost:8080/falcon; override:
-FALCON_URL=ws://gateway.example.com/falcon ./microservice/target/kyc-microservice
+# defaults to http://localhost:8080 (Camunda REST); override:
+CAMUNDA_REST_ADDRESS=http://gateway.example.com:8080 ./microservice/target/kyc-microservice
 ```
 
 ## What's inside the binary
@@ -43,15 +43,14 @@ FALCON_URL=ws://gateway.example.com/falcon ./microservice/target/kyc-microservic
 - The Nano engine's wasm blob shipped inside `nano-bernd` (kept by
   `-H:IncludeResources=nano-bernd/.*`)
 - Chicory (pure-Java wasm interpreter — AOT-compiles cleanly)
-- Jackson + java.net.http WebSocket for the outer Falcon transport
+- Stock `io.camunda:camunda-client-java` for the outer REST job worker
 
 ## Reflection config
 
 `microservice/src/main/resources/META-INF/native-image/reflect-config.json`
 flags the `EmbeddedEngine`, `ActivatedJob`, and `WasmManifest` types
-because `EmbeddedNanoTransport` (in `camunda-client-java-falcon`) uses
-reflection to talk to them — Graal's closed-world compilation needs this
-so the methods aren't stripped.
+because `nano-bernd` uses reflection to talk to them — Graal's
+closed-world compilation needs this so the methods aren't stripped.
 
 ## Notes
 

package/templates/embedded-graalvm-starter/microservice/pom.xml

@@ -22,15 +22,15 @@
     <maven.compiler.source>21</maven.compiler.source>
     <maven.compiler.target>21</maven.compiler.target>
 
-    <camunda-client.version>1.1.0</camunda-client.version>
+    <camunda-client.version>8.9.11</camunda-client.version>
     <nano-bernd.version>0.2.0</nano-bernd.version>
     <native.maven.plugin.version>0.10.3</native.maven.plugin.version>
   </properties>
 
   <dependencies>
     <dependency>
-      <groupId>io.github.jwulf</groupId>
-      <artifactId>camunda-client-java-falcon</artifactId>
+      <groupId>io.camunda</groupId>
+      <artifactId>camunda-client-java</artifactId>
       <version>${camunda-client.version}</version>
     </dependency>
     <dependency>

package/templates/embedded-graalvm-starter/microservice/src/main/java/com/example/KycMicroservice.java

@@ -1,15 +1,15 @@
 /*
  * KYC Microservice — embedded-Nano demo (ADR 0005).
  *
- *   [ Nano IDE gateway ]                         [ This JVM process ]
- *          │                                             │
+ *   [ Outer BPMN engine ]                          [ This JVM process ]
+ *          │                                              │
  *   models/onboarding.bpmn                        ┌─ OuterKycService ─┐
- *   (deployed by IDE)                             │ Falcon WebSocket  │
+ *   (deployed to the engine)                      │ Camunda REST      │
  *          │                                      │ verify_kyc worker │
- *          │  Falcon WebSocket (NanoTransport.falcon)│                │
- *          │◄──────────────── verify_kyc ───────────┤                │
- *          │                                      │        │         │
- *          │                                      │        ▼         │
+ *          │  stock Camunda REST (activateJobs)   │                   │
+ *          │◄──────────────── verify_kyc ─────────┤                   │
+ *          │                                      │        │          │
+ *          │                                      │        ▼          │
  *          │                                      │ ┌─ InnerKycService ─┐
  *          │                                      │ │ Bernd embedded    │
  *          │                                      │ │ engine + kyc.bpmn │
@@ -23,10 +23,14 @@
  *          │                                      │ └───────────────────┘
  *          │◄──── completeJob(decision) ──────────┤
  *
+ * The outer engine can be Camunda 8, Camunda Self-Managed, or a Nano
+ * gateway — we only speak stock Camunda REST on the outer path.
+ *
  * Two bounded contexts, two files:
- *   - OuterKycService owns the Falcon wire-up. Onboarding team's boundary.
- *   - InnerKycService owns the embedded engine + inner flow. Compliance team's
- *     boundary. Trivially extractable into its own process.
+ *   - OuterKycService owns the REST job worker wire-up. Onboarding team's
+ *     boundary.
+ *   - InnerKycService owns the embedded engine + inner flow. Compliance
+ *     team's boundary. Trivially extractable into its own process.
  *
  * This class only wires them together and keeps the JVM alive.
  */
@@ -37,15 +41,17 @@ import java.util.concurrent.CountDownLatch;
 
 public final class KycMicroservice {
 
-  // Set FALCON_URL to override; defaults to the Nano IDE gateway's Falcon endpoint.
-  private static final String DEFAULT_FALCON_URL = "ws://localhost:8080/falcon";
+  // Set CAMUNDA_REST_ADDRESS to override; defaults to the Nano IDE gateway's
+  // REST endpoint. A stock Camunda 8 gateway on :8080 also works (same REST
+  // API).
+  private static final String DEFAULT_REST_ADDRESS = "http://localhost:8080";
 
   public static void main(final String[] args) throws Exception {
-    final URI falconUrl = URI.create(
-        System.getenv().getOrDefault("FALCON_URL", DEFAULT_FALCON_URL));
+    final URI restAddress = URI.create(
+        System.getenv().getOrDefault("CAMUNDA_REST_ADDRESS", DEFAULT_REST_ADDRESS));
 
     final InnerKycService inner = InnerKycService.boot();
-    final OuterKycService outer = OuterKycService.boot(falconUrl, inner);
+    final OuterKycService outer = OuterKycService.boot(restAddress, inner);
 
     Runtime.getRuntime().addShutdownHook(new Thread(() -> {
       outer.close();

package/templates/embedded-graalvm-starter/microservice/src/main/java/com/example/OuterKycService.java

@@ -1,70 +1,78 @@
 /*
- * Outer KYC service — wires the onboarding gateway's `verify_kyc` job type to
- * the InnerKycService over Falcon.
+ * Outer KYC service — wires the outer engine's `verify_kyc` job type to the
+ * InnerKycService over stock Camunda REST.
  *
- * Bounded context: onboarding owns the outer gateway (the deployed
- * onboarding.bpmn, this is the service task that satisfies it). This class
+ * Bounded context: onboarding owns the outer engine (the deployed
+ * onboarding.bpmn; this is the service task that satisfies it). This class
  * knows nothing about how the KYC decision is produced — it just delegates
  * to InnerKycService.verify(customerId) and completes the outer job with the
  * returned decision.
  *
- * If InnerKycService moved out to its own JVM/process, the only thing that
- * changes here is the field type + how it's injected — the verify call site
- * stays intact.
+ * The outer engine can be Camunda 8, Camunda Self-Managed, or a Nano
+ * gateway — we only speak stock Camunda REST here. If InnerKycService moved
+ * out to its own JVM/process, the only thing that changes here is the field
+ * type + how it's injected — the verify call site stays intact.
  *
- * Concurrency: maxJobs=1 (serial). The InnerKycService's embedded engine is
- * driver-bound; handling multiple concurrent outer verify_kyc activations
- * would let inner activateJobs polls race across KycContexts. Scale
- * horizontally with more microservice instances.
+ * Concurrency: maxJobsActive=1 (serial). The InnerKycService's embedded
+ * engine is driver-bound; handling multiple concurrent outer verify_kyc
+ * activations would let inner activateJobs polls race across KycContexts.
+ * Scale horizontally with more microservice instances.
  */
 package com.example;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.nanobpm.camunda.falcon.FalconTransport;
-import com.nanobpm.camunda.transport.NanoTransport;
+import io.camunda.client.CamundaClient;
+import io.camunda.client.api.response.ActivatedJob;
+import io.camunda.client.api.worker.JobWorker;
 import java.net.URI;
+import java.time.Duration;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 
 public final class OuterKycService implements AutoCloseable {
 
   private static final String OUTER_JOB_TYPE = "verify_kyc";
   private static final String OUTER_WORKER = "kyc-microservice";
-  private static final long JOB_LEASE_MS = 30_000L;
-  private static final long CALL_TIMEOUT_SECONDS = 5L;
+  private static final Duration JOB_LEASE = Duration.ofSeconds(30);
+  private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(30);
 
-  private final NanoTransport transport;
+  private final CamundaClient client;
   private final InnerKycService inner;
+  private JobWorker worker;
 
-  private OuterKycService(final NanoTransport transport, final InnerKycService inner) {
-    this.transport = transport;
+  private OuterKycService(final CamundaClient client, final InnerKycService inner) {
+    this.client = client;
     this.inner = inner;
   }
 
   /**
-   * Open a Falcon connection to the onboarding gateway and subscribe to
-   * verify_kyc. Delegates every activation to {@code inner}.
+   * Open a stock Camunda REST connection to the outer engine and subscribe
+   * to verify_kyc. Delegates every activation to {@code inner}.
    */
-  public static OuterKycService boot(final URI falconUrl, final InnerKycService inner)
-      throws Exception {
-    final NanoTransport transport = NanoTransport.falcon(falconUrl);
-    transport.connect().get(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS);
-    System.out.println("[outer] connected to onboarding gateway at " + falconUrl);
+  public static OuterKycService boot(final URI restAddress, final InnerKycService inner) {
+    final CamundaClient client = CamundaClient.newClientBuilder()
+        .restAddress(restAddress)
+        .preferRestOverGrpc(true)
+        .defaultRequestTimeout(REQUEST_TIMEOUT)
+        .build();
+    System.out.println("[outer] connected to onboarding engine at " + restAddress);
 
-    final OuterKycService service = new OuterKycService(transport, inner);
-    transport.subscribe(new FalconTransport.Subscription(
-        OUTER_JOB_TYPE, OUTER_WORKER, 1, JOB_LEASE_MS, null, service::handleVerifyKyc))
-      .get(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+    final OuterKycService service = new OuterKycService(client, inner);
+    service.worker = client.newWorker()
+        .jobType(OUTER_JOB_TYPE)
+        .handler((jobClient, job) -> service.handleVerifyKyc(job))
+        .name(OUTER_WORKER)
+        .maxJobsActive(1)
+        .timeout(JOB_LEASE)
+        .open();
     System.out.println(
         "[outer] subscribed to " + OUTER_JOB_TYPE
-        + " — start an onboarding instance in the IDE");
+        + " — start an onboarding instance");
     return service;
   }
 
-  private void handleVerifyKyc(final JsonNode job) {
-    final String outerJobKey = job.get("jobKey").asText();
-    final JsonNode vars = job.path("variables");
-    final String customerId = vars.path("customerId").asText("cust-unknown");
+  private void handleVerifyKyc(final ActivatedJob job) {
+    final long outerJobKey = job.getKey();
+    final Map<String, Object> vars = job.getVariablesAsMap();
+    final String customerId = String.valueOf(vars.getOrDefault("customerId", "cust-unknown"));
 
     System.out.println();
     System.out.println("═══════════════════════════════════════════════════════════════");
@@ -76,7 +84,7 @@ public final class OuterKycService implements AutoCloseable {
     try {
       decision = inner.verify(customerId);
     } catch (final Exception e) {
-      // Do NOT complete the outer job — let Nano's job timeout drive a retry.
+      // Do NOT complete the outer job — let the engine's job timeout drive a retry.
       System.err.println("[inner] flow failed for customer=" + customerId + ": " + e);
       e.printStackTrace(System.err);
       System.err.println("[outer] NOT completing " + OUTER_JOB_TYPE
@@ -88,12 +96,10 @@ public final class OuterKycService implements AutoCloseable {
     System.out.println("═══════════════════════════════════════════════════════════════");
 
     try {
-      // ABI v2 embedded engine ignores completeJob variables; but the OUTER
-      // gateway is the full Nano engine and does accept them, so the
-      // exclusive gateway in onboarding.bpmn can branch on `decision`.
-      transport
-          .completeJob(outerJobKey, Map.of("decision", decision, "customerId", customerId))
-          .get(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+      client.newCompleteCommand(job)
+          .variables(Map.of("decision", decision, "customerId", customerId))
+          .send()
+          .join();
     } catch (final Exception e) {
       System.err.println("[outer] complete failed: " + e.getMessage());
     }
@@ -101,10 +107,9 @@ public final class OuterKycService implements AutoCloseable {
 
   @Override
   public void close() {
-    try {
-      transport.close();
-    } catch (final Exception ignored) {
-      // best effort
+    if (worker != null) {
+      try { worker.close(); } catch (final Exception ignored) { /* best effort */ }
     }
+    try { client.close(); } catch (final Exception ignored) { /* best effort */ }
   }
 }