8.1 Changelog

Replace the unmaintained react-text-mask dependency with a fully internal <MaskedInput> implementation covering the same feature set.

The expression parser sandbox checked property access values against React.createFactory, which was removed in React 19 and is undefined. This caused any computed property lookup returning undefined (e.g. an object key miss with nullish coalescing) to falsely throw an error.

With multi-tenancy, AxelorCache.asMap() returns a map view for current tenant. Using it on static field either cause null tenant if called before multi-tenancy module, or resolution to tenant of first usage. AxelorCache.asMap() should be called on demand only.

Moreover, on app shutdown, we need to iterate over the cache for each tenant.

Affected usage:

Calendar views with context-based domains (e.g. self.user.id = :_userId) displayed no events because the calendar widget’s _domainContext overwrote the action-view’s context variables during filter merge. The DataStore’s original context is now preserved by spreading it first when building the calendar’s domain context.

This fixes x-popup-maximized attribute to control the maximized (i.e., fullscreen) state of popup windows for relational fields.

The expression parser sandbox only blocked the regular Function constructor, allowing code execution through AsyncFunction, GeneratorFunction, and AsyncGeneratorFunction constructors obtained via .constructor on async, generator, and async generator function instances.

The expression parser now blocks this and dangerous properties such as __proto__, prototype, and constructor, including computed access, to prevent sandbox escapes and prototype pollution vectors.

Allows specifying custom allocation size for sequences used by entities. This can be useful for optimizing performance.

This allows to provide custom entity sequence allocation size in multiple ways:

When allocationSize is 1, it forces Hibernate to execute a SELECT nextval('seq') query for every single entity saved. Having an allocationSize greater than 1 is the performance tuner for database inserts. It controls how many IDs Hibernate fetches from the database in a single network call.

Add support to simply drag and drop files directly into binary/binary-link/image widgets. Users can now drag files from their desktop or file explorer directly into the widget area, bypassing the traditional system file picker dialog

The summary bar can be used to show summary by the selected rows, page and action in a grid view.

In calendar views, the context now includes the following information:

React-based HTML applications embedded can now retrieve some information (theme/language/…​) and subscribe to changes via a listener pattern.

Show archived boolean is replaced by selection as follow

Improved audit tracking with asynchronous queue-based processing to improve the performance. Now the listener performs a lightweight capture of raw data and inserts simple AuditLog rows into the database. The main operation has no more complex logic executed, reducing the execution time. After the transaction commits, a background thread picks up the AuditLog entries and handle the tracking process : generate the associated mail message and emails sending.

Since 8.0, binary fields declared in domains now map to bytea instead of oid. bytea is the modern standard for binary data up to a few hundred megabytes. oid is a legacy mechanism that introduces significant maintenance headaches and should only be used for specific "streaming" use cases. For compatibility reasons, this adds support to use oid database type for binary fields. This can be enabled by adding large="true" attribute on field definition.

Implement two new methods in entity repositories :

The mail messages widget now supports real-time updates via WebSocket. This is necessary since the introduction of asynchronous audit tracking. The implementation also supports distributed environments using Redis/Valkey for message broadcasting.

On grouped grids, the grouped results can become inconsistent due to sorted fields. This automatically prioritizes grouping fields in the sort order to ensure consistent grouping records through pagination.

Here is the list of backend dependencies upgraded :

Since Hibernate 6.x, it creates a sequence per entity hierarchy instead of a single sequence hibernate_sequence. So the sequential attribute is no longer needed and should be removed from entity definitions. It is marked as deprecated and will be removed in further version. All entities will now use their own sequence.

When creating a new record in a custom model form view, the jsonModel field is now automatically set to match the view’s jsonModel value.

This ensures custom model records are properly initialized with the correct jsonModel identifier without requiring additional backend actions or manual intervention.

Observers whose event parameter is a supertype are now correctly invoked when a subtype event is fired. For example, an observer declared as onModel(@Observes ModelEvent e) is now triggered when a ContactEvent extends ModelEvent is fired, as required by the CDI specification.

Previously, observer lookup used an exact class match, so supertype observers were never notified for subtype events.

Observer methods are now inherited by subclasses, as required by the CDI specification. Previously, only methods declared directly on the bound class were discovered; inherited observer methods were silently ignored.

Overriding rules are also respected: if a subclass overrides an observer method, only the overriding version is invoked (the parent version is suppressed), matching standard Java method override semantics.

When an observer method is declared in a generic base class (e.g. onSave(@Observes SaveEvent<T> event)), the event parameter type is now correctly resolved to the concrete type argument supplied by the subclass (e.g. SaveEvent<Contact> for class ContactHandler extends GenericHandler<Contact>).

Previously, the unresolved type variable T was used for matching, causing generic observer methods to either never match or match too broadly.