2026.2 to 2027.0
1. Changed Behavior of the onValueChange Process
Overview
With this update, the onValueChange process handles changes from the valueProcess differently (onValueChangeTypes property with the change type PROCESS).
The new behavior:
- The onValueChange process is no longer triggered when the field receives its initial value from the valueProcess.
- The onValueChange process only triggers when the valueProcess produces a new value that is different from the initial value.
The comparison to the last value is not new. This rule already applied before this update. What is new is that the initial value from the valueProcess no longer counts as a change. The process is skipped in that case.
In short: the onValueChange process only handles real changes to the value. The initial value delivery is no longer considered as a real change.
Why the change?
-
No unwanted executions when the entity is loading. Previously, the onValueChange process could run while the entity data was only being loaded. This could cause unintended side effects and was hard to debug.
-
Easier to use. In most cases, you no longer need additional if conditions in the onValueChange process to handle unintended executions. For example, checks like "is the state NEW/EDIT?" or "was the value really set by the user?". The platform now handles this for you.
-
Enforcing best practice. The onValueChange process should only handle real changes to the value. Real changes are triggered by an explicit interaction with the entity. Initial values belong in the valueProcess.
What has changed in detail?
Before
- The onValueChange process also ran when the valueProcess wrote the initial value into the field. The general rule "only on a change compared to the last value" already applied. But the initial value delivery was still treated as a triggering change.
After
- When the valueProcess writes the initial value into the field, the onValueChange process is skipped.
- The onValueChange process only runs when the value changes compared to the last value. This includes a new value from the valueProcess that is different from the initial value.
Related change: RECORD removed from onValueChangeTypes
In the same context, the change source RECORD is no longer supported in onValueChangeTypes. This change source reacted to values that were loaded from the RecordContainer. The ADITO Designer ignores existing RECORD entries and removes them when the entity is saved. This is part of the same cleanup. Initial values should not trigger the onValueChange process, no matter if they come from the record or from the valueProcess.
See: Upgrade Guide 2026.1 to 2026.2, Section 9
Example: What no longer works
Scenario
You have a simple entity with a dataless recordContainer. The entity is used purely for data entry. The entity has two entity fields:
selectTemplate. This field gets a pre-selected value from its valueProcess. The changes type inonValueChangeTypesincludesPROCESS.description. This field holds the text of the selected template.
The onValueChange process of selectTemplate should write the text of the selected template into description.
Old behavior
The onValueChange process also ran for the initial value from the valueProcess. This made it possible to pre-fill description using the onValueChange process of selectTemplate. As soon as the view opened, description already contained the default template text. No code for description itself was needed.
New behavior
The initial value from the valueProcess no longer triggers the onValueChange process. The process only runs when the value actually changes to something different from the last value. For example, when the user changes the template selection.
Result: description stays empty until the user actively changes the template selection.
Solution
Move the initial value logic where it belongs. Set the initial value with a valueProcess on the description field itself.
Example valueProcess for selectTemplate. This process provides the pre-selected value:
if (vars.get("$this.value") == null)
{
// Provide the initial template
result.string("TEMPLATE_DEFAULT");
}
Example valueProcess for description. This process provides the initial template text:
if (vars.get("$this.value") == null)
{
// Pre-fill the description with the default template text
result.string(getTemplateText("TEMPLATE_DEFAULT"));
}
The onValueChange process of selectTemplate:
// onValueChange of the field "selectTemplate"
// This process only runs on a real change. That means the user
// selected a template different from the initial value.
let selectedTemplate = vars.get("$local.value");
neon.setFieldValue("description", getTemplateText(selectedTemplate));
Migration checklist
- Audit all entity fields whose
onValueChangeTypesincludePROCESSand whose valueProcess sets an initial value. - Identify logic that relied on the onValueChange process running for the initial value. For example, pre-filling other fields or initializing state.
- Move this initial value logic into a valueProcess on the affected target field or fields. See the example above.
- Remove guard conditions that are no longer necessary from onValueChange processes. For example recordState/viewMode checks or null checks for initial values.
- Test data entry scenarios. New records with a dataless recordContainer are especially affected. Confirm that initial values appear as before.
2. Field values in $sys.selectionRows are not automatically populated
What changed
The loading of entity data has been optimized so that fields are only calculated when they are actually used. In the past, fields of a row were calculated more generously, so values in $sys.selectionRows were often filled — whether or not anyone used them.
Now, if a field is read purely via $sys.selectionRows (e.g. selectionRows[0]["SOME_FIELD"]), the field could be not calculated and the value could be empty.
Why it matters
Anywhere your customizing reads field values out of the $sys.selectionRows variable (marked rows of a table view), those values can now be empty if the field isn't explicitly declared. This affects any process that triggers internal/programmatic entity accesses, not just a specific operation.
Note:
$sys.selectionRowsis only supported when the recordsRecipe is not enabled. If recordsRecipe is enabled for the entity, you cannot rely on this variable at all.
Recommended actions
Two ways to fix missing values — the first is the sustainable, recommended one:
- Prefer reading the field directly via the field variable instead of going through
selectionRowswhen you are working on a single row (e.g.grantDeleteProcess):
vars.get("$field.<FIELD_NAME>")
instead of
vars.get("$sys.selectionRows")[0]["<FIELD_NAME>"]
This works because the use of vars.get makes sure that the value is available.
- If you must keep
selectionRows(and recordsRecipe is not enabled): declare the dependency explicitly before accessing it:
vars.dependOn("$field.<FIELD_NAME>")
Only with this declaration it is guaranteed that the field will be calculated and available in the selection rows data.
TLDR: avoid using the $sys.selectionRows variable in processes that can use the field variables instead. In places where $sys.selectionRows is used, make sure that all required entity fields are loaded by declaring a dependency via vars.dependOn.