@esfaenza/flow-builder 20.3.11 → 20.3.12

package/README.md

@@ -142,6 +142,7 @@ sono opzionali e rifiutano con `MissingService` se non sovrascritti.
 | `listForms` / `listFormParameters` | astratti |
 | `listEnumTypes`, `listEvents`, `listSubflowCandidates` | astratti |
 | `describeObject`, `listFieldValues` | opzionali |
+| `listEnumValues(enumType)` | opzionale — i **valori** di un tipo di enumerazione, cioe' i nomi scrivibili in `enumValue` (§4.2, §4.6). `listEnumTypes` e' l'altra meta' e non basta: quella dice quali tipi esistono, questa quali valori ha un tipo. `enumType` e' esattamente l'`objectType` della risorsa, del parametro o del **membro** di una classe (§4.7.1): la risposta e' del tipo, non del punto di uso, e la cache e' per nome del tipo. Lista vuota = "non lo so" — il valore si scrive a mano, e un tipo sconosciuto risponde vuoto, non 404 |
 | `listStructures`, `describeStructure(className)` | opzionali — le classi e i loro membri per le risorse `Structure` (§4.7). `listStructures` e' l'**elenco delle classi** senza membri; `describeStructure` restituisce la **descrizione** di una classe (`className`, `label`, `members`), non un array nudo (§4.7.1). Senza, le classi non sono verificabili e il nome si scrive a mano: "non lo so", non "non esiste". I tre esiti sono distinti: `members` popolato = elenco autorevole, `members: []` = membri non dichiarati (si digita, nessuna accusa), rifiuto `StructureNotFound` = classe non registrata (si segnala la **classe**) |
 
 | §6.5 Esecuzione | |
@@ -203,6 +204,14 @@ qualsiasi.
 dalla mappa delle uscite invece di essere «ramo di errore» per tutti: su uno stage di
 orchestrazione quel ramo e' lo **step rifiutato**, non un guasto.
 
+La stessa mappa distingue i rami di **recupero da errore** (`isFaultRecovery`: Record\*,
+ActionCall, ScriptCall, Wait) dagli altri, perche' lasciarne uno vuoto non significa «il
+percorso finisce qui» ma «se questo fallisce l'interview termina `Failed` e le modifiche
+vengono annullate» (§3.5). L'editor delle uscite lo dice come promemoria — non col colore
+d'avviso, perche' rinunciare al recupero e' la scelta piu' comune — e il backend lo segnala
+con `FAULT_CONNECTOR_MISSING`, che e' un `Warning` e non blocca niente. Lo stage di
+orchestrazione ne resta fuori: la §7 non lo comprende.
+
 Un tipo con un **discriminatore** compare come piu' voci, una per valore: il Collection
 Processor e' «Ordina» e «Filtra», non «ordina o filtra». Sono due gesti diversi — un `Sort`
 vuole `sortOptions`, un `Filter` vuole condizioni (§5.5) — e sceglierli dalla palette evita di
@@ -311,6 +320,25 @@ quindi l'editor dice di filtrare per le colonne della chiave invece di far cerca
 nell'elenco non c'e'. Restano `<select>` i dizionari chiusi — tipi di dato, operatori,
 enumerazioni — dove non c'e' niente da scrivere a mano.
 
+**Valori di enum.** Un `Enum` ha due meta' e servono entrambe: l'`objectType` dice **quale tipo** —
+e quello resta un `<select>`, perche' l'elenco dei tipi e' un dizionario chiuso — mentre i **valori**
+di quel tipo arrivano da `listEnumValues(objectType)` e sono cio' che finisce in `enumValue` (§4.2,
+§4.6). Senza la seconda chiamata all'utente resta una casella di testo su un insieme chiuso, che e'
+il modo piu' facile di scrivere un valore che il runtime non riconoscera'. Li propone
+`<fb-enum-value-picker>`, che il `<fb-value-editor>` monta al posto della casella di testo appena il
+tipo della destinazione e' `Enum`: vale quindi in una condizione, in un filtro, nel valore iniziale
+di una risorsa, in un parametro di action o di form, in un Assignment e in una `Map` di un Transform.
+Cio' che si scrive e' il **nome**: `numericValue` viene mostrato accanto al valore — aiuta a
+riconoscerlo in dati legacy — ma un numero in `enumValue` sarebbe un altro tipo (§13.18). Elenco
+vuoto resta "non lo so" — primitiva non esposta, tipo senza valori dichiarati, `objectType` ancora
+da scegliere — e allora il valore si digita; con l'elenco popolato un valore fuori elenco e' un
+**avviso**, perche' nessun codice della §7 lo blocca ed e' l'editor ad accorgersene prima del runtime.
+
+Perche' l'editor conosca il tipo della destinazione serve saperlo: in un Assignment arriva da
+`getWritableReferences` (per corrispondenza esatta del nome: su `Cliente.Stato` resta ignoto), in una
+condizione e in un filtro dal riferimento o dal campo a sinistra, in un Transform dal **membro** della
+classe di destinazione. Dove il tipo non si sa, il campo resta generico invece di indovinare.
+
 Lo stesso controllo, nella variante `<fb-name-picker>`, vale per **ogni altro nome che il flow
 prende da fuori**: tipo di action e action, script, form, i nomi dei loro parametri di ingresso
 e di uscita, il flow di uno step in background e dei suoi evaluation flow, il flow invocato da