feat(intent): postings reverses - red-storno reversal on a source void (#6308)

* feat(intent): transitions - guarded on-demand status flips (void/cancel/close)

A document whose create-time process has ended (invoice ISSUED, entry POSTED)
has no declarative affordance left to change its status: process triggers fire
only on create/update/delete, and actions: only opens a custom page. The new
top-level transitions: block adds one - a per-record button that moves the
record into a designated EntityStatus, guarded server-side:

  transitions:
    - name: VoidInvoice
      forEntity: Invoice          # must declare a function: EntityStatus relation
      from: [3, 4]                # allowed source status seed ids
      setStatus: 8                # target status seed id
      when: "Paid == 0"           # optional <Field> ==|!= <number> guard (Calc semantics)
      label: Void
      icon: ban

Two halves, the generates pattern: TransitionsIntentGenerator (@order(470))
contributes the per-record button to <project>-custom-action (descriptor
carries the endpoint); GlueIntentGenerator.buildTransitions pre-renders the
allowed-statuses expression and the Calc-backed when guard into the
transitions glue collection, rendered by Transition.java.template into a
@controller at gen/events/<ClassName>Transition/run. The controller re-loads
the record, returns 409 with the reason when a guard fails, flips ONLY the
status column via the targeted updateProperty (no -updated re-fire), and
publishes -transitioned - the same channel workflow setters publish, so
postings:/integrations observe a manual void exactly like a workflow
transition (the enabler for red-storno reversal postings).

ControllerInvoker: a CharSequence return no longer stamps text/plain over a
content type the controller set explicitly (the transition controller returns
JSON); default unchanged when unset.

Verified:
- unit: TransitionsIntentTest (7) + GlueTransitionsTest (2) + full
  engine-intent suite green; ControllerInvokerBindingTest +2 content-type
  tests, full engine-java suite green
- IntentEmissionCoverageIT extended (fixture transition + emission tokens +
  runtime: cancel 200 with the status flipped, wrong-status 409, when-guard
  409 leaving the record untouched) and green

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat(intent): postings reverses - red-storno reversal on a source void

The postings glue could post a document when a source reaches a status, but
not UN-post it: a voided/cancelled source left its journal entry standing.
The new reverses: mode pairs with the transitions: void primitive:

  postings:
    - name: invoicePosting
      event: { onTransition: Invoice, when: "Status == 3" }
      creates: JournalEntry
      backReference: Invoice
      rule: { ... }
      items: [ ... ]
    - name: invoiceStorno
      event: { onTransition: Invoice, when: "Status == 8" }   # the void transition
      reverses: invoicePosting
      storno: Storno            # the created entity's to-one SELF-relation to the original

Semantics (red storno - the accounting correction convention): the reversal
inherits creates/backReference/rule/map/items from the reversed sibling and
re-derives them from the source with every item amount expression NEGATED on
the SAME debit/credit side (never swapped - turnovers stay honest). It locates
the ORIGINAL through the empty storno link (back-reference set, link null) and
skips fail-soft when none exists (the source was never posted); its creation
stamps the link. Both handlers' idempotency guards discriminate by that link:
the reversal counts only linked rows, the reversed sibling counts only
unlinked ones (stornoProperty/stornoFilterProperty in the glue). The reversal
lands as a normal new document - DRAFT status init, number placeholder,
checks, the accountant review-and-Post task.

Verified:
- unit: PostingsReversesIntentTest (5: parse + sibling/inherited-keys/storno
  validations) + GluePostingsReversesTest (negated exprs, inherited
  coordinates, storno keys on both entries); full engine-intent suite green
- IntentEmissionCoverageIT extended (Doc + PostDoc/VoidDoc transitions +
  docPosting/docStorno fixture; emission tokens for negation/fail-soft/link;
  runtime: post -> balanced Entry appears, void -> the reversal appears with
  negative debit AND credit lines and the storno link to the original) - green

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(intent): report filter translates bare to-one relation names to their FK columns

A report filter like `Status != 8` (a to-one RELATION of the source, not a
field) passed through buildWhere untranslated - fields rewrote to their
qualified physical columns but relation names did not, so the generated query
carried a nonexistent column and failed at SQL time. Bare to-one relation
names now rewrite to the FK column (Invoice."INVOICE_STATUS"), with guards
so join-alias tokens from the dotted-ref pass (Customer."CUSTOMER_NAME")
and already-quoted columns are left intact.

Found by a suite emission audit: an overdue-invoices report excluding a
VOIDED status generated 'AND Status != 8' verbatim into the WHERE.

Verified: ReportIntentGeneratorTest +1 (bare relation translated, dotted-ref
alias unmangled), full class green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: delchev

components/engine/engine-intent/CLAUDE.md

@@ -702,17 +702,45 @@ static List<Map<String, Object>> buildGeneratesForTest(IntentModel model) {
     private static List<Map<String, Object>> buildPostings(IntentModel model, Map<String, EntityIntent> byName,
             Map<String, String> compositionParents, IntentSettings settings, IntentGenerationContext context) {
         List<Map<String, Object>> out = new ArrayList<>();
+        // A reversal posting's storno link doubles as the discriminator between the reversed
+        // sibling's own documents (link empty) and reversals (link set) - the SIBLING's handler
+        // must filter its idempotency lookup by it too, so map: base posting name -> storno.
+        Map<String, String> stornoOfReversed = new LinkedHashMap<>();
         for (org.eclipse.dirigible.components.intent.model.PostingIntent posting : model.getPostings()) {
+            if (posting.getReverses() != null && !posting.getReverses()
+                                                         .isBlank()
+                    && posting.getStorno() != null) {
+                stornoOfReversed.put(posting.getReverses(), IntentNaming.pascalCase(posting.getStorno()));
+            }
+        }
+        for (org.eclipse.dirigible.components.intent.model.PostingIntent posting : model.getPostings()) {
+            boolean isReverse = posting.getReverses() != null && !posting.getReverses()
+                                                                         .isBlank();
+            // Reversal mode: creates/backReference/rule/map/items come from the reversed sibling;
+            // the reversal contributes its own event plus the storno link, and every item amount
+            // expression is negated (same sides - red storno).
+            org.eclipse.dirigible.components.intent.model.PostingIntent effective = posting;
+            if (isReverse) {
+                for (org.eclipse.dirigible.components.intent.model.PostingIntent candidate : model.getPostings()) {
+                    if (candidate != posting && posting.getReverses()
+                                                       .equals(candidate.getName())) {
+                        effective = candidate;
+                    }
+                }
+                if (effective == posting || posting.getStorno() == null) {
+                    continue; // parser already reported it
+                }
+            }
             if (posting.getName() == null || posting.getName()
                                                     .isBlank()
-                    || posting.getEvent() == null || posting.getCreates() == null) {
+                    || posting.getEvent() == null || effective.getCreates() == null) {
                 continue; // parser already reported it
             }
             if (!settings.shouldGenerate("postings", posting.getName())) {
                 LOGGER.info("Settings opt-out: keeping existing handler for posting [{}] (not generated)", posting.getName());
                 continue;
             }
-            EntityIntent creates = byName.get(posting.getCreates());
+            EntityIntent creates = byName.get(effective.getCreates());
             EntityIntent itemsEntity = creates == null ? null : compositionChild(creates, byName);
             if (creates == null || itemsEntity == null) {
                 continue; // parser already reported it
@@ -769,22 +797,27 @@ private static List<Map<String, Object>> buildPostings(IntentModel model, Map<St
             e.put("itemsEntity", itemsEntity.getName());
             e.put("itemsPerspective", IntentEntities.resolvePerspective(itemsEntity.getName(), compositionParents));
             e.put("itemsFk", IntentNaming.pascalCase(creates.getName()));
-            e.put("backRefProperty", IntentNaming.pascalCase(posting.getBackReference()));
+            e.put("backRefProperty", IntentNaming.pascalCase(effective.getBackReference()));
+            // Reversal coordinates: the reversal handler locates the original through the empty
+            // storno link and stamps it on its own creation; the reversed sibling's handler filters
+            // reversals OUT of its idempotency lookup through the same property.
+            e.put("stornoProperty", isReverse ? IntentNaming.pascalCase(posting.getStorno()) : "");
+            e.put("stornoFilterProperty", isReverse ? "" : stornoOfReversed.getOrDefault(posting.getName(), ""));
             // Rule lookup: a single match selector, columns referenced from the items.
-            boolean hasRule = posting.getRule() != null && posting.getRule()
-                                                                  .get("entity") != null;
+            boolean hasRule = effective.getRule() != null && effective.getRule()
+                                                                      .get("entity") != null;
             e.put("hasRule", hasRule);
             java.util.Set<String> usedRuleColumns = new java.util.LinkedHashSet<>();
             if (hasRule) {
-                String ruleEntityName = String.valueOf(posting.getRule()
-                                                              .get("entity"));
+                String ruleEntityName = String.valueOf(effective.getRule()
+                                                                .get("entity"));
                 e.put("ruleEntity", ruleEntityName);
                 // A setting rule entity (the normal case) lives under the global Settings perspective.
                 EntityIntent ruleEntityIntent = byName.get(ruleEntityName);
                 e.put("rulePerspective", ruleEntityIntent != null && ruleEntityIntent.isSetting() ? "Settings"
                         : IntentEntities.resolvePerspective(ruleEntityName, compositionParents));
-                Map<?, ?> match = (Map<?, ?>) posting.getRule()
-                                                     .get("match");
+                Map<?, ?> match = (Map<?, ?>) effective.getRule()
+                                                       .get("match");
                 Map.Entry<?, ?> selector = match.entrySet()
                                                 .iterator()
                                                 .next();
@@ -793,16 +826,16 @@ private static List<Map<String, Object>> buildPostings(IntentModel model, Map<St
             }
             // Header assignments: copy / literal / {placeholder} template - pre-rendered Java.
             List<Map<String, Object>> headerAssignments = new ArrayList<>();
-            if (posting.getMap() != null) {
-                for (Map.Entry<String, String> entry : posting.getMap()
-                                                              .entrySet()) {
+            if (effective.getMap() != null) {
+                for (Map.Entry<String, String> entry : effective.getMap()
+                                                                .entrySet()) {
                     headerAssignments.add(postingAssignment(entry.getKey(), entry.getValue()));
                 }
             }
             e.put("headerAssignments", headerAssignments);
             // Item rows: rule(...) refs read the rule row; expressions run through Calc on the source.
             List<Map<String, Object>> itemRows = new ArrayList<>();
-            for (Map<String, String> row : posting.getItems() == null ? List.<Map<String, String>>of() : posting.getItems()) {
+            for (Map<String, String> row : effective.getItems() == null ? List.<Map<String, String>>of() : effective.getItems()) {
                 Map<String, Object> rendered = new LinkedHashMap<>();
                 List<Map<String, Object>> assigns = new ArrayList<>();
                 String rowGuard = "";
@@ -832,7 +865,9 @@ private static List<Map<String, Object>> buildPostings(IntentModel model, Map<St
                     } else {
                         FieldIntent target = fieldOf(itemsEntity, cell.getKey());
                         int scale = target != null && target.getScale() != null ? target.getScale() : 2;
-                        assign.put("expr", "Calc.eval(\"" + value.replace("\"", "\\\"") + "\", source, " + scale + ")");
+                        // Reversal: the SAME expression negated on the SAME side (red storno).
+                        String expr = isReverse ? "-(" + value + ")" : value;
+                        assign.put("expr", "Calc.eval(\"" + expr.replace("\"", "\\\"") + "\", source, " + scale + ")");
                     }
                     assigns.add(assign);
                 }

components/engine/engine-intent/src/main/java/org/eclipse/dirigible/components/intent/generator/GlueIntentGenerator.java

@@ -70,6 +70,37 @@ public class PostingIntent {
      * {@code == 0} on a source field).
      */
     private List<Map<String, String>> items;
+    /**
+     * Reversal (red storno) mode: names a SIBLING posting in this block whose created document this
+     * posting reverses. The reversal re-derives the sibling's header and items from the source with
+     * every amount expression NEGATED on the SAME side (never swapped - turnovers stay honest), links
+     * {@link #storno} to the original, and skips fail-soft when no original exists (the source was
+     * never posted). {@code creates}/{@code backReference}/{@code rule}/{@code map}/ {@code items} are
+     * inherited from the sibling and must not be declared here.
+     */
+    private String reverses;
+    /**
+     * The created entity's to-one SELF-relation linked to the reversed (original) document - required
+     * with {@link #reverses}. Doubles as the discriminator between the sibling's own documents (link
+     * empty) and reversals (link set) for both handlers' idempotency guards.
+     */
+    private String storno;
+
+    public String getReverses() {
+        return reverses;
+    }
+
+    public void setReverses(String reverses) {
+        this.reverses = reverses;
+    }
+
+    public String getStorno() {
+        return storno;
+    }
+
+    public void setStorno(String storno) {
+        this.storno = storno;
+    }
 
     public String getName() {
         return name;

components/engine/engine-intent/src/main/java/org/eclipse/dirigible/components/intent/model/PostingIntent.java

@@ -2280,6 +2280,47 @@ private static void validatePostings(IntentModel model, Set<String> usesAliases,
                     issues.add(subject + " event requires `when: \"<Property> == <status seed id>\"`");
                 }
             }
+            // Reversal mode: creates/backReference/rule/map/items are inherited from the reversed
+            // sibling; the reversal declares only its own event + the storno self-link.
+            if (posting.getReverses() != null && !posting.getReverses()
+                                                         .isBlank()) {
+                PostingIntent sibling = null;
+                for (PostingIntent candidate : model.getPostings()) {
+                    if (candidate != posting && posting.getReverses()
+                                                       .equals(candidate.getName())) {
+                        sibling = candidate;
+                    }
+                }
+                if (sibling == null) {
+                    issues.add(subject + " reverses unknown posting [" + posting.getReverses() + "] - it must name a sibling"
+                            + " posting in this block");
+                    continue;
+                }
+                if (posting.getCreates() != null || posting.getBackReference() != null || posting.getRule() != null
+                        || posting.getMap() != null || (posting.getItems() != null && !posting.getItems()
+                                                                                              .isEmpty())) {
+                    issues.add(subject + " is a reversal - creates/backReference/rule/map/items are inherited from ["
+                            + posting.getReverses() + "] and must not be declared");
+                }
+                EntityIntent reversed = sibling.getCreates() == null ? null : byName.get(sibling.getCreates());
+                if (posting.getStorno() == null || posting.getStorno()
+                                                          .isBlank()) {
+                    issues.add(subject + " requires `storno: <self relation>` - the created entity's link to the reversed document");
+                } else if (reversed != null) {
+                    RelationIntent storno = toOneRelationByName(reversed, posting.getStorno());
+                    if (storno == null || !reversed.getName()
+                                                   .equals(storno.getTo())
+                            || storno.isCrossModel()) {
+                        issues.add(subject + " storno [" + posting.getStorno() + "] must be a to-one SELF-relation of ["
+                                + reversed.getName() + "]");
+                    }
+                }
+                continue;
+            }
+            if (posting.getStorno() != null && !posting.getStorno()
+                                                       .isBlank()) {
+                issues.add(subject + " declares storno without reverses - the storno link belongs to the reversal posting");
+            }
             // creates + items child + backReference
             EntityIntent creates = posting.getCreates() == null ? null : byName.get(posting.getCreates());
             if (creates == null) {

components/engine/engine-intent/src/main/java/org/eclipse/dirigible/components/intent/parser/IntentParser.java

@@ -209,6 +209,21 @@ composition is opt-in.
   A missing rule row or null referenced column SKIPS the posting (the unposted worklist = final-status
   documents with no back-referencing target), never throws. All writes go through the generated
   repositories, so numbering/status-init/`checks:` fire on the created document.
+  **Reversal mode (red storno):** a posting with `reverses: <sibling posting name>` undoes the
+  sibling's document when the source is voided/cancelled - pair it with a `transitions:` void:
+  ```yaml
+    - name: invoiceStorno
+      event: { onTransition: SalesInvoice, model: kf-billing, when: "Status == 8" }   # the void status
+      reverses: salesInvoicePosting     # sibling posting in this block
+      storno: Storno                    # the created entity's to-one SELF-relation to the original
+  ```
+  `creates`/`backReference`/`rule`/`map`/`items` are inherited from the sibling and must not be
+  declared. Semantics: locate the ORIGINAL (back-reference = this source, storno link empty) - none
+  -> skip fail-soft; create the negated copy (every item amount expression negated on the SAME
+  debit/credit side - never swapped) with the `storno` link stamped; idempotent (rows carrying the
+  link are the reversal's own; the sibling's guard symmetrically counts only rows without it). The
+  reversal lands as a normal new document (DRAFT status init, numbering, checks), dated by its own
+  `map`-inherited header - corrections post into the open period.
 - `calculatedOnCreate` / `calculatedOnUpdate` - an expression the generated repository assigns to the
   property on insert / update. Prefer a **neutral arithmetic expression** for numeric totals
   (`"Quantity * Price"`, `"round(Net * 0.2, 2)"`) - the SDK `Calc` evaluator runs it on the server and