Vai al contenuto
Verificata

JavaScript

Vero codice JS, compilato al salvataggio, per la logica che un programma dichiarativo non riesce a esprimere.

Un programma JavaScript contiene vero codice sorgente in scriptData.value, la via di fuga per la logica che un Leggi dati, Imposta dati o Batch dichiarativo non riesce a esprimere. Viene compilato al salvataggio (save_prog esegue la stessa build di Studio e restituisce data.compile, { ok: true, dependencies } oppure { ok: false, error }) e viene eseguito con una vera API per campi, tabelle ed eventi, non solo per un elemento DOM.

Proprietà

Il contratto di esecuzione

Il sorgente è un semplice corpo asincrono, senza export né wrapper, eseguito come:

js
async function (params, xu, SESSION_ID, SESSION_OBJ, jobNoP, $container, func, glb, APP_OBJ, evt) {
  /* your source */
}

params sono i parametri del chiamante già valutati. xu è l'API di runtime: campi, righe del database, eventi, HTTP. await funziona liberamente perché il wrapper è asincrono. Qui le virgolette vanno bene, a differenza del valore di un attributo xu-script.

Leggere e scrivere una tabella

js
const raw = await xu.get_field_value(`rows_json_v`);
const rows = typeof raw === `string` ? JSON.parse(raw || `[]`) : raw || [];
for (const row of rows) {
  await xu.dbs_create(`392_tbl_…`, { CNT_Name: row.name || `` });
}
// dbs_read resolves to an ARRAY of { id, value } rows, the row id on .id, fields under .value.
const all = await xu.dbs_read(`392_tbl_…`, {}, [], null, 999);
await xu.set_field_value(`saved_rows_v`, all.map((r) => ({ row_id: r.id, name: r.value?.CNT_Name || `` })));

I metodi dbs_* accettano il _id della tabella, mai il suo nome. La proiezione fields di dbs_read è facoltativa: [], il valore predefinito, restituisce tutti i campi, e un elenco di id di campo restituisce solo quelli.

Passare i dati: campi, non parametri

call_native_javascript non valuta i wrapper di parametri {value, fx}: uno script chiamato in questo modo riceve gli oggetti letterali {value: "", fx: "@field"}, non i valori risolti. Lo schema affidabile: il chiamante mette prima il payload in un campo (un passo update o un input xu-bind), chiama lo script con parameters: {} vuoto e lo script legge con xu.get_field_value e restituisce il risultato con xu.set_field_value. Chiamare da un altro script è diverso: i parametri di xu.call_javascript(prog_id, {...}) arrivano come passati.

Richiamare un programma JavaScript

Esempio pratico

Dichiara i parametri

Le voci di progFields diventano i nomi degli argomenti della funzione wrapper, nell'ordine di chiamata.

Scrivi il corpo

Un semplice corpo di funzione asincrona, usa return per restituire un valore se call_evaluate_javascript lo leggerà.

Chiamalo e leggi compile.ok

Dopo save_prog, controlla data.compile.ok: una compilazione fallita salva comunque il documento con un build_error allegato.

Crea un nodo JavaScript sotto Programmi, scrivi il sorgente nell'editor di codice, aggiungi i parametri nella griglia Campi. Il salvataggio ricompila automaticamente, gli errori compaiono nell'editor.

xml
<meta lang="json5">
{
  id: "normalize_student_name",
  menuTitle: "Normalize Student Name"
}
</meta>

<params lang="json5">
{
  in: { raw_name_in: "string" },
  out: { normalized_name_out: "string" }
}
</params>

<code>
return (@raw_name_in || "")
  .trim()
  .split(/\s+/)
  .filter(Boolean)
  .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
  .join(" ");
</code>
json
{
  "properties": { "menuType": "javascript", "menuName": "Slugify Name", "fileExtension": "js" },
  "scriptData": { "value": "return name.toLowerCase().replace(/[^a-z0-9]+/g, '-');", "dependencies": [] },
  "progFields": [
    { "id": "b2c3d4e5-…", "data": { "field_id": "name", "type": "virtual" }, "props": { "fieldType": "string" } }
  ]
}