All Classes and Interfaces
Class
Description
What
<call> and <subflow> share: everything but where the child graph comes from.What
<wait> and <boundary> share: the trigger they wait on, a timer (
delay + unit, or until), a condition (when), a message with a
key, or a signal, and the node to continue to once it fires.Redisson cache with configurability of cache eviction policies.
The shared base of workflow nodes:
id, title and description; positions
live in the workflow's Layout.What one AI call may do for its user: the one place the AI asks, so every path answers alike.
A field whose value a call handed to the model.
Who refuses a field: the user's own permissions, or the AI's.
A refusal raised from deep inside a tool — a path checked while a query is built — carrying the
words
Denials gave it.A question the browser would put to the user: an
alert from an action, a button's
prompt, or a request to re-authenticate.An action chain as its actions' definitions write it out — read, never run: groups flattened with
their conditions, validations and conditions with their checks, records and attributes with their
fields, Java steps and navigation by name.
An
action-record or action-attrs: what it sets.A check of a validation or condition.
An
action-condition: checks that set field errors, which stop the chain.A field an
action-record sets, or an attribute an action-attrs sets.An
action-group, its items in order.A Java step:
class:method, directly or through an action-method.A name no action answers to: it does nothing, and a run skips it.
An
action-view: navigation, returned to the caller rather than followed.Another kind of action: a script, a report, an export, a web service...
A place in a chain where a run meets something only a person or the browser handles.
save, validate, close or new, handled by the client.An action already written out above it, not repeated: a cycle, or too deep.
One element of a chain, written out.
An
action-validate: its alerts, errors and messages in order.The only way a session asks for a decision: wherever the browser would put a dialog in front of
the user.
An implementation of
Response to be used with controllers.The
ActionValidateBuilder can be used to quickly define ActionValidate manually,
especially when setting message to Response.setData(Object) or with Response.The
ActionView.ActionViewBuilder can be used to quickly define ActionView manually,
especially when setting view to ActionResponse.Which action-view is the view for a model.
Generation-side handle for one chat run.
What a node outside execution (email, agent, message) may ask of the walk it runs in: who it runs
as, what record it is about, the variables it may read and the cascade it belongs to.
What is known about an activity's outside effect when it failed: whether an email or agent call
that failed may already have gone out, so an operator knows whether re-sending duplicates it.
Which adapter serves which provider type.
Exports all agents as a zip of ai/agents/<code>.md files.
An agent's permissions, as entries: what an agent file's
permissions lists and what the
Agent Builder sets, one entry per object — "*" for every operation on every model,
"Order read update" for those operations on one.One entry: the object, and the operations granted on it.
Seeds AiAgent records from ai/agents/<code>.md files.
Invokes an AI agent (
ref) with the <prompt> template, then continues to
next.One field of an
<agent> node's declared answer: the compiled form of
<output><field/></output>.Resolves the agent/model/provider config from the DB and builds a real
LangChain4jChatProvider so the LLM actually responds.Invokes an AI agent, binds its answer as
agent, then advances.Aggregation method behind a measure column or summary value.
Whether a dataset's records are individual rows or already-grouped measures.
What one agent may do on some models, within the user's own permissions and never beyond them.
A field whose value entered a chat: every later model call in the chat sends it again.
Orchestrates whole-bundle AI config import/export by fanning out to the per-type services in
dependency order.
Thrown by
AiService operations when an AI call fails.Role-based access resolver for the AI module: who may use the assistant, and with which agents.
What the AI may not read, and where: every AI call when global, else the calls of the agents it
lists and the calls sent to the models and providers it lists — any one of them.
Usage limits from
AiUsagePolicy: the monthly token quota and the request rate limit, each
the maximum across the active policies that apply to the user: the global ones, and those listing
one of their roles, their group or themselves.Per-model rate limiter, keyed by model code with the model's configured rateLimit.
What the AI may not read on one model, whatever the user's own permissions allow: the fields
listed, or, listing none, the whole model.
Seeds the bundled AI config, every type
AiConfigService imports, once on startup.Helper around the
AiSeed marker table that records what has been seeded.AI config record types tracked by the
AiSeed marker table.Public API for using AI capabilities from Java code.
Fluent builder for agent invocations.
A source of seed files: relative path -> raw bytes.
What each tool call was and how it went, on one line.
Records AI usage metrics.
How much the users it applies to may ask in the chat panel: everyone when global, else the users
of the roles, groups and users it lists.
Per-user rate limiter, keyed by user code.
Thrown by
ChatStreamRegistry.begin(java.lang.String, java.time.Duration) when the chat already has a live run.Anthropic's
GET /v1/models.Service keeping track of when API keys are used.
The application module scans the classpath and finds all the
AxelorModule and installs
them in the dependency order.Adapter class for
AtomicLong to conform to the DistributedAtomicLong interface.The base abstract class with update logging feature.
Hibernate listener handling audit concerns: creation field stamping, sequence generation, change
tracking and admin access control on insert, update and delete.
Stores raw audit data for asynchronous processing.
Service responsible for processing AuditLog.
Represents an interface for queuing and triggering the processing of audit logs.
Represents the complete audit record for a specific entity within a transaction.
This class provides change tracking for auditing and notifications.
Enables the second-level collection cache (
READ_WRITE) for a curated set of
authentication association collections.Records successful authentication attempts.
Job to delete the
AuthenticationEvent older than the retention period.Records successful authentications as
AuthenticationEvent.Manages password validation by aggregating all registered
PasswordPolicy rules.Service for password reset.
Deprecated.
The
AuthService class provides various utility services including password encryption,
password match and saving user password in encrypted form.Manages session attributes.
Represent a selectable theme
Authenticator implementation for API key-based authentication.
The two parts composing an API key.
Direct client for API key-based authentication.
Authenticator implementation for local username/password authentication.
Cache interface for wrapping different cache implementations
Callback client finder that doesn’t fail when some indirect clients are unavailable.
CSRF token generator without rotating tokens
CSRF matcher with custom cookie name and header name.
GStringTemplateEngine implementation that allows to pass CompilerConfiguration.
Shiro JCache Manager where we can pass configuration to created caches.
Kryo5Codec implementation with any required custom configuration.
The entry-point of application module.
Hibernate Cache region factory based on Redisson with ability to reuse Redisson client from
configuration
Session Manager
StreamingTemplateEngine implementation that allows to pass CompilerConfiguration.
Distributed topic.
A listener for messages received on a
AxelorTopic.Web Security Manager
Session storage evaluator
Checks for basic auth request header and finds basic auth client when appropriate.
Bean configurator using reflection
A singleton class that can be used to get instances of injetable services where injection is not
possible.
Reading a parked node's boundaries: when the next one comes due, and which one has fired.
What a park recorded: when it opened, its absolute deadlines, and which non-cancelling
boundaries have fired.
One thing a park listens for: a name, the key narrowing it (null for a signal), and the
boundary that asked, null for the node's own trigger.
A way out of the node named by
host that the host's own trigger may never provide, such
as "escalate after 7 days".A
StreamWriter that appends serialized SSE frames to an ActiveStream instead of a
socket.Callback interface for build progress and completion notifications.
Immutable context for a build job execution.
The first check of every builder tool, and of
inspect_process: only an AI administrator
may run them, whatever agent they are linked to.Exception thrown when a build operation fails.
Interface for executing build jobs.
Immutable build options.
Deprecated.
Weak key derivation (PBKDF2WithHmacSHA1, 1024 iterations) and instance-scoped salt.
Coordinator that routes encrypt/decrypt operations between the legacy
BytesEncryptor
($AES$), BytesEncryptorPbkdf2Sha256 ($AESv1$), and BytesEncryptorPbkdf2Sha512 ($AESv2$).AES encryptor operating on raw byte arrays using PBKDF2WithHmacSHA256 key derivation, supporting
CBC and GCM operation modes.
AES encryptor operating on raw byte arrays using PBKDF2WithHmacSHA512 key derivation, supporting
CBC and GCM operation modes.
A builder of
AxelorCache instancesCache configuration
Computes or retrieves values, based on a key, for use in populating an
AxelorCache.Cache provider information
Caffeine cache
Caffeine cache builder
Caffeine loading cache
The
CallMethod annotation can be used to mark any arbitrary method to allow them with
ActionMethod besides the standard controller methods.Runs the workflow named by
ref, a definition in its own right with its own identity,
model and revision.Resolves a new model's values, in order of authority: what the provider reported, then the
family's defaults, then defaults for the model type.
Dispatches durable record changes under fenced leases, completing with the database work.
Thrown when a password change attempt fails due to a policy violation or other constraint.
Membership resolution for shared chats.
Effective role of a user on a chat.
A chat changed outside a request of its own, so connected clients should refresh it.
Handle returned by
ChatStreamer.stream(com.axelor.ai.chat.ChatRequest, com.axelor.ai.chat.stream.StreamWriter) — allows cancellation and awaiting completion.Creates non-streaming
ChatModel instances for background tasks and resolves which model
to use based on agent configuration.What a utility call is for, and whose: logged with every call its model makes.
Extension point for the chat loop.
Cluster-wide "who has which chat open": one entry per (room, user, session), refreshed by the
client's ~25s re-JOIN heartbeat and expiring shortly after it stops — dead sessions (no close
frame) self-heal within one TTL.
Cache value: what the client's Avatar needs (image with initials fallback).
Abstraction for calling an LLM and receiving streaming chunks via callbacks.
Receives streaming chunks from an LLM response.
What entered a chat, and whether a model may receive it.
A model call refused for what the chat holds; the client offers a new chat for it.
What a check of the chat's data against a request's model depends on: the fields that entered
it, which are only ever added, so their count moves with them; the agents' permissions and the
restrictions in force; and the model, with its provider.
A chat stream call as the loop runs it.
The body of a client's chat stream call.
Outcome of a single LLM turn, delivered via
ChatProvider.Listener.onFinish(com.axelor.ai.chat.ChatResult).Main orchestrator entry point.
Multi-step agentic loop that streams LLM responses and executes tool calls.
Registry of in-flight chat runs, backed by the unified cache API: in-memory under caffeine,
distributed under Redisson/JCache — chosen by the app's cache provider config, nothing
AI-specific.
A client-tool call the run paused on.
Owns AI chat persistence: loads history, saves the user row, progressively upserts the assistant
row as the agent loop runs, and finalizes on stream end.
Result of preparing a stream: a
Turn to thread through the frames plus a possibly
modified request (with history preloaded, the user message saved, or — for sub-agent resume —
an isolated child context).Keeps a claim alive while its work runs, so the lease measures whether the holder is alive rather
than how long the work takes.
The three columns that say a row is being worked on, and by whom.
The helper class to find sub types of a given super class.
Scans bundled seed files from the classpath under a given root (e.g.
Provides class utility methods.
Resolves the IP address of the client that originated a request, from the headers set by a
reverse proxy.
Holds the tools that work on the form open in the browser to the rules the record tools are held
to.
Human-readable names of the Axelor and pac4j authentication clients.
A
StreamWriter that collects text deltas in memory instead of writing SSE.Custom color converter for logback using jansi.
Which action(s) require a comment: neither (
none), only complete, only
reject, or both (always).The result of compiling a definition: a plan and no violations, or the complete list of
structural violations and no plan.
How much of the matching data a dataset actually carries.
Create computed view from base view and their extensions.
Compute xml of computed views from base view and their extensions.
This class provides some methods to deal with Content-Disposition as defined in RFC 6266
Builder for
ContentDispositionThe Context class represents an
ActionRequest context.A wrapper around a
Callable that enables execution within a context-aware environment.A wrapper around a
Runnable that enables execution within a context-aware environment.This interface is used by
ContextHandler to return real context entity.The
ContextHandler provides seamless way to access context values using proxy.Factory to create
ContextHandler.Places per-turn context beside the message it serves, not at the top of the prompt.
Manages the LLM context window by transparently trimming message history when it exceeds the
model's input token limit.
Condenses the stretch of conversation that is rolling out of the context window.
Fires the post-login failure event for credentials rejected by the pac4j clients.
Checks a criteria object before a tool builds a query out of it.
A field a criterion may match against.
What a tool knows about the fields a criterion may name.
One filter condition, or a group of them.
This class provides api to work with csv files using
CSVParser and CSVPrinter.This
CSVLogger class logs all errors during the import into a specific file.The
ExportWriter for CSV data format.How a custom field (
MetaJsonField) is typed and read in a query, wherever it is stored:
in a custom model's record, or in the JSON column of an entity the field was added to.This
DataScriptHelper class can be used to effectively use the GroovyShell to
evaluate dynamic groovy expressions.One result column's identity, type and presentation metadata.
A resolved dataset: the records plus everything needed to say honestly what they are.
The JSON spelling of dataset enums, for code that writes or reads them by hand.
One option of a column's or parameter's selection.
A parameter value as it was actually applied, for provenance.
Where a dataset came from.
A query-scope aggregate, computed unwindowed over the filtered set.
A caller's answer where the browser would ask the user.
Default implementation of
AuthPasswordManager.Default implementation of
DigitsPasswordPolicy.Default implementation of
LengthPasswordPolicy.Default implementation of
LowerCasePasswordPolicy.Default implementation of
NotCodePasswordPolicy.Default implementation of
NotSamePasswordPolicy.Default implementation of
PatternPasswordPolicy.Default implementation of
ScorePasswordPolicy.Default implementation of
SpecialCharsPasswordPolicy.Default implementation of
UpperCasePasswordPolicy.Time unit for a workflow time trigger (
<start unit="...">).How the AI tools word a refusal: the operation, the model and what was refused, and nothing about
the rule behind it.
Where data the AI reads goes: the model serving the call, and its provider — what a policy lists
to hold data back from it.
Defines a password policy based on the required minimum number of digit characters.
A tool as discovered from a remote MCP server, with its RAW JSON-Schema string.
Common atomic long operations found in both
Service for getting distributed-aware objects.
Provides per-dimension
EmbeddingStore instances for knowledge base storage.The service can be used to migrate all the encrypted field values.
The
Encryptor interface.The unchecked exception is thrown by
Encryptor classes if there is any error while
encrypting or decrypting values.The walk stops here.
Terminates the current path: a completion, a terminate that stops the whole run, or -- with
error -- a named failure the caller can match.This class provides helper methods for model objects.
Annotation for configuring database sequence-based ID generation for JPA entities.
A custom sequence identifier generator for entities.
Captures the raw snapshot of an entity's state changes.
Provides information about UI widget representing this enumeration constant.
Mark the field to be included in equality test.
What a
<wait> or <boundary> is triggered by.What a trigger asks of the author, and what the runtime does with it.
The advance data exporter.
Advance export options.
A column holding one value per related record of a collection.
The
ExportWriter is an abstraction to write exported data.Names the fields a user message was sent with.
This class is a straightforward implementation of the
TrackField annotationFactory class for creating and managing the
Store instance used by the application.This class provides some helper methods to deal with files.
Why the LLM stopped generating.
Fixture class to load YAML fixtures for JPA entities.
Sends a request at OpenAI's Flex tier and, when Flex refuses it, once more at Standard.
A blocking model, for the background tasks that call the utility model.
What a percentage column's stored number means.
How a value is presented.
Something a browser would do with a form that a session does not, found from the definitions
alone.
A node of a form's record tree: the root, a line of one of its collections, a line of a line, to
any depth.
How a segment names its line.
One step down the tree: a line of a collection of the node above.
A node's path and a name under it, as
FormPath.split(java.lang.String) finds them.What one
FormSession.run(java.util.List<com.axelor.meta.headless.FormStep>, com.axelor.meta.headless.ActionInteraction) or FormSession.resume(com.axelor.meta.headless.Decision, com.axelor.meta.headless.ActionInteraction) came to: the record as the session
holds it, whether it was saved, what the actions set and said, and why the run stopped.A message the browser would have shown.
A record an action wrote in its own round trip, committed with it (
ActionWrites).A form on a record, run on the server: steps change the record and its lines and run the chains
the form declares for them, each in the context of the record or line it acts on, as the web
client runs it.
What a session needs to know about a form, compiled from views once and cached: the model, its
hooks, fields and buttons, the fields a record is read with, the limits of running it without a
browser, and, for each one-to-many, the spec of a line there — a line is a form too.
A button or a menu item of the form.
A field of the form's model, a custom field (
attrs.color), a dotted field the form
shows (customer.email) or a dummy field of the view.Everything a
FormSession holds between two requests: which form, the record tree and its
open lines, the steps and where the run is in them, and the open question with what to do with
each answer.Where a procedure run paused in a chat is kept until its owner answers: on the generic cache
(local, or distributed across nodes), under
form:<chatId>#<toolCallId>, as JSON, so
whichever node receives the answer carries on.An operation on a form's record tree.
Adds a line: the line's defaults, its
onNew in the line's context, then the seed.Asks a button's
prompt as a question, then runs its onClick.Commits a line into its collection: the collection's
onChange, in the parent's context.Takes a line out of its collection; the collection's
onChange runs straight away.Runs a chain the form declares for the node — a hook, a field's
onChange, a button's
onClick — and nothing else.Saves the root with its lines: commits the open lines, runs
onSave, saves, reads the
root back, runs onLoad.Writes values into their nodes, in order, each followed by its field's
onChange in that
node's context.Parses YAML frontmatter + markdown body from a document string.
Allows to fine-tune global search indexing.
The
GlobalSearchEntity represents a single free-text-search match.The
GlobalSearchEntityField represents the matched fields of a GlobalSearchEntity.The indexer to initialize search index.
The
GlobalSearchParams is used to send global search request parameters.The
GlobalSearchResult represents the search result as the name suggests.The
GlobalSearchService to implement global search.The Gemini API's
GET /v1beta/models.A custom Groovy AST transformer to validate property accesses against the policy settings.
A custom groovy ast transformer to validate type of objects against the policy settings.
The implementation of
Templates for groovy string template support.This object stores the groups.
A conditional
UPDATE ... WHERE whose row count decides a winner.An assignment that is HQL rather than a value.
JUnit5 test extension that creates injector using the modules provided with
GuiceModules
configuration.Custom
JobRunShellFactory to use GuiceJobRunShell.Abstract class to run Junit5 tests
Provides the Guice modules to be used by JUnit5 test extension.
Custom
StdSchedulerFactory to use GuiceJobRunShellFactory.Runs forms on the server, with no browser: the entry point of headless forms.
Registers the listener that tells
ActionWrites what a form's actions write: each write
once its transaction commits, on the thread that committed it.Service to manage and provide access to the set of HibernateListenerConfigurator instances.
This class provides some helper methods escaping, rendering, replacing HTML text
The real HTTP seam.
This class provider methods for internationalization (I18n) services.
The database backed
ResourceBundle that loads translations from the axelor database.Custom
ResourceBundle.Control class to create I18nBundle instances.This
MessageInterpolator uses current user locale to translate hibernate validation
messages.Holds identity verification requirements for a user.
Determines which identity verification method a user needs and performs the verification.
Exception thrown when a file fails validation (e.g.
This class provides some helper methods to deal with Image in Reports
The default implementation of
MailAccount for IMAP/IMAPS accounts.The
Importer interface to run data import.Import task configures input sources and provides error handler.
The
Inflections defines rules for singular, plural inflections.The
Inflector provides various methods to transform words to plural, singular, titles,
class names, table names etc.The cell format of a collection exported inline: one value per related record, separated by
|.Defends against prompt injection by injecting security rules into the conversation.
What the builder builds from: the agents, skills (with their procedures), tools, knowledge bases
and chat models, each with what uses it.
The digest of how a model's forms work — ways in, states, fields, buttons with their client
expressions, hooks, every chain written out with the questions it can ask, workflows — and, given
a skill, how its procedures stand against the forms as they are now.
Represents a password policy violation returned by
PasswordPolicy.validate(com.axelor.auth.db.User, java.lang.String).Matches IP addresses against an IP address or a CIDR range.
Converts GraalVM guest
Values into plain, context-independent Java objects.Where one activation of a split stands: whether its join may continue, and if not, whether it
ever will.
Compiles and runs a
<join>: the split it closes (for) and its completion policy
(wait), parsed once so the threshold cannot change while branches are out.What a
<join> waits for: all (every selected branch arrives or ends), any
(the first arrival continues, the rest are cancelled), or quorum (the first
quorum="N" arrivals continue, the rest are cancelled).This class provides easy access to
EntityManager and related API.The class loader for domain objects.
A generic implementation of
Model.A Guice module to configure JPA.
The JPA implementation of the
Repository.A custom Hibernate scanner that scans all the classpath entries for all the
Model classes
annotated with Entity.This class provides some helper static methods to deal with custom sequences.
This class provides some useful methods in JPA context, can be used as a base class for services
to make it more convenient.
The jdbc task interface.
Exports AiKnowledgeBase records to ai/knowledge/
/KB.yaml (+ content.md for the TEXT
source).Seeds AiKnowledgeBase (+ its RECORD/TEXT sources) from ai/knowledge/<code>/ directories:
KB.yaml (config + RECORD sources) and an optional content.md (one TEXT source).Guice module that wires all knowledge base (RAG) components.
Queries the vector store at chat time to retrieve relevant chunks for an agent.
A retrieved text chunk with metadata.
This class provider methods for localization (L10n) services.
Adapts a LangChain4j
StreamingChatModel to the ChatProvider interface.The designer's drawing of a workflow: node positions and edge routes.
How one edge is drawn.
Where one graph's nodes and edges are drawn: the workflow's own, or a subflow body's.
Where one node sits on the canvas.
One point of an edge's route, its ends included, relative to the edge's source node.
The drawing of one subflow's body, keyed by the subflow's id.
The
LeaderElectionWorker class is responsible for managing a leader election mechanism
among multiple instances of a distributed system.Defines a password policy based on the required minimum password length.
Listener interface provides some events fired by Importer.
Lists model names the current agent may read for its user.
Local build executor that runs Gradle builds in a subprocess.
A topic for single-instance usage
The logger configuration builder using logback-classic.
Provides support for SLF4J Logger injection.
Typed events produced by the agentic loop.
The loop completed normally.
The loop encountered an unrecoverable error.
A message to add to conversation history (persisted by plugins).
An SSE stream event to send to the client.
The loop is pausing — waiting for user action (approval, client tool result).
Consumer for agentic loop events.
Defines a password policy based on the required minimum number of lowercase characters.
The
MailAccount provides a single definition MailAccount.getSession() to create account
specific Session instance.The model to store email addresses.
The
MailBuilder defines fluent API to build MimeMessage and if required can send
the built message directly.Defines constants for mail server configuration settings.
Job to fetch emails.
The model to store message flags like unread, starred, voted etc.
The model to store followers details of a document.
The model to store different kind of messages like system notifications,
comments, email messages etc.
Event for mail messages
Service responsible for converting consolidated AuditLog (i.e.,
AuditState) into MailMessageParses a
MimeMessage and stores the individual parts such as context text, attachments
etc.The
MailReader provides features to read mails.The
MailSender provides features to send mails.The mail service defines interface for sending/reading mails.
Default
MailService implementation.This class can be used to map params to Java bean using reflection.
Normalized result of an MCP tool call.
Creates/uses live connections to a remote MCP server.
Immutable, detached snapshot of the connection data an MCP call needs.
Validates an MCP server URL before any outbound connection: HTTPS only, host on the administrator
allowlist, and not resolving to a private/loopback/link-local address.
A validated URL paired with the address checked during DNS resolution.
Rejects JSON-Schema constructs the engine's schema converter (
AgentResolverPlugin) and
the LangChain4j JsonObjectSchema model cannot faithfully represent.Tests connectivity and synchronizes a remote MCP server's tools into
AiTool rows.Executes a synced MCP tool through the shared client factory.
Builds a stable, provider-safe
AiTool.code for a synced MCP tool, formatted as
<clientCode>_<sanitizedRemoteName> and capped at 64 characters.Resolves structured user mentions into trusted model context.
Defined the
MetaMenu policiesMenuNode visitor interfaceVisitor decision
What a delivered message hands to the walk it wakes: the binding an author reads, and the cascade
bookkeeping they never see.
How many subscribers a
<send> expects.This object stores the xml actions.
This object stores the actions menu.
This object stores the enum types.
This object stores the fields.
This object stores the files.
This class provides some helper methods to deal with files.
This object stores the custom filters.
Repository implementation to handle custom model records.
This object stores the menus.
This object stores the models.
This object stores the modules.
A saved query and its parsed definition, for a caller that inspects the definition before
running it.
This class provides some utility methods to scan class path for resources/classes.
This object stores the scheduler configuration.
This object stores the selects.
This object stores the select items.
This object stores custom sequences.
Invalidates
MetaStore JSON-field caches once per transaction that changes a
cache-affecting entity.This object stores the xml views.
A
WorkflowCatalog over active MetaWorkflow rows.The actions behind the run viewer.
Service responsible for managing Multi-Factor Authentication (MFA) for users.
Lightweight projection of
MFA for simple usage; unneeded fields are
left out of the projection.What is parked on a definition, and where: the read half of the parked-run mover.
A page of a position's runs, and how many there are in all.
What one Apply did, row by row.
One row's outcome.
One row of the mover: a position, an action, and which runs behind the position it reaches.
What a row does.
Where one position may go on a chosen revision, and what else may be done to it.
A node a position may be moved onto.
One opening of the parked-run mover: the two pickers and the selected revision pair's mapping.
A revision as the pickers show it.
One position, and where it may go on the selected target.
This class defines static helper methods to deal with MIME types.
Mistral's
GET /v1/models.The base abstract model class to extend all domain objects.
Abstract base for system tools that operate on a specific model.
A selected model with its values resolved, used only when creating one.
Marker interface for tool input records that operate on a specific Axelor model.
The single HTTP seam a sync goes through, so adapters can be tested against recorded fixtures
without touching the network.
A model a tool acts on: an entity, or a custom model whose records are
MetaJsonRecord.A model call that sent nothing for longer than its model may stay silent.
This class is a straightforward implementation of the
Track annotationThe ModuleInfo class acts as a wrapper and provides a simplified interface for managing and
retrieving information about a specific module.
This annotation can be used to declare a column as name column that can be used to give name to
the record.
Collects one row per node visited in the run in progress and writes them once, when the run
finalizes.
One buffered visit, mutable while the node is executing.
A no-operation implementation of the
AuditQueue interface.Default no-op provider used as a base binding.
Default no-op tool executor that rejects all tool calls.
Defines a password policy that prevents using the user code (login) in the password.
Defines a password policy that prevents reusing the current password.
A JPQL equality that also matches null, since
= :param never matches a null column.Specifies the precedence of null values within query result sets.
This class defines from static helper methods to deal with objects.
MCP client factory backed by the official SDK, with cached, periodically refreshed connections.
Ollama's
GET /api/tags.OpenAI's
GET /v1/models.What a tool does to a model's records.
The read, write, create and remove flags of an agent's permission, as the operations it allows.
Cipher operation modes.Destinations an outbound AI request must never reach, shared by the MCP egress guard and the HTTP
tool executor so the two classifications cannot drift apart.
Writes the one row a
<send> produces, message or signal.One field of the answer an
AgentNode expects: rendered into the prompt and checked
against the answer before any node reads agent.result.One value an
<agent> answer's string field may take, told to the model and checked in the
answer.The JSON type an
<agent> answer's field must have: the types JSON itself distinguishes.Cipher padding schemes.Executes transactions in parallel and handles rollback if any exception occurs.
Annotates a record component to provide metadata for JSON schema generation.
One place runs are parked and how many: a graph position, not a run.
Where a position sits in its run's structure, which decides where it may move.
One parked run behind a position, as its picker shows it.
Why a walk stopped short of an end.
Stopped because a split of its own had to wait.
Stopped on a person or a timer, under its own key.
A node's own park on the row the scheduler polls: the branch inside a split, since a run row
holds only one key and wake time, else the run's position.
Tracks open text and reasoning parts to enforce the part lifecycle rule:
*-start → N ×
*-delta → *-end with a single consistent ID per run.Represents a single password policy rule.
Defines a password policy based on a required regex pattern.
What a
<send> carries besides its address: the author's expression, evaluated in the
sending walk and stored as JSON.Represents a pending export operation with its associated input stream and file name.
Manages pending export files.
Represents a pending export file.
This object stores the permissions.
What an agent's permission or a restriction names: a model's full name, a package (
com.axelor.sale.db.*, no sub-packages), a custom model's name, or * for every model.The platform's permissions for
user: model and field checks from QueryAccessValidator, row predicates from rows.Represents a user-facing description of an active password policy requirement, intended for
display as guidance on the login or change-password page before the user submits.
The default implementation of
MailAccount for POP3 accounts.A named, reviewed run of a form's own steps, carried by a skill: open the action-view's form on a
record (or a new one), set fields, click buttons, save — each step handled as the web client
would.
A value the model supplies.
How an alert is answered when no one can answer it.
One step of a procedure: what a user does on the form or on a line of it.
A new line: its defaults, its
onNew, then the seed, literals or eval:.A button's click: its prompt, then its
onClick chain.A line into its collection: the collection's
onChange.A line out of its collection; the collection's
onChange runs at once.A chain the form declares, run in a record's context: a hook by name (
onLoad) or a
chain as a field or button writes it.The Save button: open lines committed,
onSave, save, read back, onLoad.Values applied in order, each field's
onChange after it in its record's context;
literals or eval:.A skill's procedures as an agent may see and run them: parsed, and only those in its scope.
Procedures that cannot be read or would not run; every problem found, each named.
The values a model gives a procedure, checked against what the procedure declares and turned into
the types its expressions read: a date is a
LocalDate, a decimal a BigDecimal, a
reference the record itself.Runs a procedure on its form, with no browser: each step as a user would do it.
An alert met during the run, and how it was answered.
The guard said no; nothing ran beyond loading the form.
How the form open beside the chat was used, when it showed the procedure's record.
What a run did.
A run stopped at a question for the user, with all it needs to carry on: the form's state, the
procedure step it stopped in (
-1 for the form's load hooks), and what the run met so
far.A message the browser would have shown, kept with a paused run.
Reads a skill's
procedures.yaml into Procedures, strictly: an unknown key, a
missing one or a value of the wrong shape is refused with its place named, never ignored.Checks procedures against the application before they can reach a chat, so a broken one is
refused where it is written — at import, and later when the builder saves a skill — rather than
failing halfway through a run.
The digest of how a model's forms work, read from their definitions — what an author writes
procedures against, and what an admin reads after an upgrade: the ways in, the states, the fields
and buttons with their client expressions verbatim, the hooks, every chain written out with the
questions it can ask, the workflows on the model.
The one way the AI reads a record: what it asks for, refused when the user may not read it, and
what comes along unasked — a name field, a relation's name — withheld with a marker.
Summarizes by asking a model, on whatever provider the conversation already uses.
This class defines from static helper methods to deal with
Properties.Knows how to ask one vendor what models it offers, and how to normalise the answer.
Exports AiProvider (+ nested models) to ai/providers/
.yaml entries.Seeds AiProvider (+ nested AiModel) records from ai/providers/<code>.yaml files.
Brings a provider's models into line with what it actually offers: fetch, apply the admin's
rules, resolve capabilities, match what already exists, write.
The
Query class allows filtering and fetching records quickly.JoinHelper class is used to auto generate
LEFT JOIN for association expressions.What a query may read: the models and fields its analysis checks, and the row predicates its
rendering weaves into the root, every join and every subquery.
The query binder class provides the helper methods to bind query parameters and mark the query
cacheable.
What a query source supports, so a client disables what is unsupported instead of inventing an
endpoint or approximating an answer.
Arbitrary join on a model with explicit ON conditions.
Join via a relational field path (e.g.,
self.customer).An analyzed query.
System tool for advanced queries using a structured JSON DSL, returning the rows of the columns a
query selects, computed or grouped.
The outcome of running a query: the records, the window they came from, and enough context to say
what they represent.
Entity results, for a query selecting whole records.
Tabular results, for a query selecting individual columns.
Resolves the current user's row-level read filter for a model into a JPQL predicate on a given
alias, binding its parameters through the renderer's binder.
What a query says about its own results.
An aggregate over the whole filtered set, computed without the result window.
A quick menu displayed on default page
An item in the quick menu dropdown
Reads a record's activity stream — the tracking notifications, comments and emails the form view
renders below the fields.
What a conversation did and settled: one written summary, plus the records it may link.
What the recap was built from, rendered as the card's footer.
A record the conversation wrote to, and how to reach it.
Links the records a recap names, and converts the result to HTML for the activity stream.
Builds a conversation's recap: one written account of what it did and settled.
The range a recap covers.
One recorded write, as the ledger reported it.
What a check on one record concluded.
One record a run is about:
jsonModel is set for a custom-model record, null otherwise.One record-driven wake source the orchestrator re-checks after every save, such as condition
waits or tasks whose
when may now hold.Adapter class for
RAtomicLong to conform to the DistributedAtomicLong interface.Redisson cache with scripted eviction
Redisson cache builder
Default Hibernate second-level cache region settings for Redisson region factories.
Redisson cache with native eviction
Redisson cache with native eviction builder
Redisson loading cache with scripted eviction
Redisson loading cache with native eviction
Redisson client provider
Adapter for
RTopic to conform to the AxelorTopic.Redisson utilities
The
Reflections utilities provides fast and easy way to search for resources and types.Uses the optional Axelor Message add-on without making it a core dependency.
The reason why a cached entry was removed
An object that can receive a notification when an entry is removed from a cache.
Re-fire policy for a workflow trigger (
<start repeat="...">).Configures the reports generated by
ReportGenerator.Default implementation of
ReportConfigurer.The report generator service.
This is a
IResourceLocator that first searches external reports directory for the
resources and falls back to module resources if not found.The repository interface defines common data access methods.
Keep track of current
Request object.This class defines CRUD like interface.
The
ResourceFinder class provides fluent api to search for resources.The class provides static helper methods to work with resources.
A file sent to the client, set with
ActionResponse.setFile(ResponseFile).Every policy, as
RestrictionImportService reads them.Policies from YAML, one file each, keyed by
name.Hands each flushed update to
the announcement.The third layer of the confused-deputy defence: before the target agent consumes a discussion
containing other members' text, an internal risk-assessor agent screens the fresh span (the human
messages since the agent's last reply) for manipulation attempts.
This object stores the roles.
Exports AI-owned roles to ai/roles/.yaml.
Seeds an auth Role from ai/roles/<slug>.yaml files.
Take a row for this transaction, or find out at once that somebody else has it.
Resolves a provider's full model list down to the few the rules ask for.
A vendor model paired with the family that claimed it.
Takes back what a run, a region or a set of branches still has in flight: approvals, parks, the
runs it called, and the run itself when it is over.
Where a run itself is: its root branch, the one position that belongs to no split.
Runs one of the procedures of the agent's skills on a record: the form's own steps, each handled
as the web client would handle it.
A caching when working with S3 as file storage using LRU (Least Recently Used) strategy: the
element that hasn't been used for the longest time will be evicted from the cache
Creates or updates an agent by code, from the fields of an agent seed file's frontmatter.
Saves a query directly as a reusable MetaQuery record.
Creates or updates a skill by code: its instructions, its text references and its procedures,
laid out as a skill directory is —
SKILL.md, references/*.md,
procedures.yaml.Creates or updates a tool by code: a script, an HTTP endpoint, an action, or a system tool the
application registers.
The default guice module for quartz scheduler.
Generates a LangChain4j
JsonObjectSchema from a Java record class and its Param
annotations.Defines a password policy based on a minimum computed strength score.
The DataScriptHelper interface to implement dynamic script evaluation support.
Runs its script body (the element text), then continues to
next.Runs an inline JavaScript body against the record context, then advances.
Agentic RAG tool — lets the LLM search knowledge bases on demand.
Supplies row-level security predicates to the renderer so they can be woven into the query at the
right place: the root model's filter is added to the WHERE clause, while each joined model's
filter is added to that join's own condition.
Count of records created and updated by a seed pass.
Shared plumbing for the per-type importers: entry iteration and the SEED_ONCE lifecycle.
Outcome of seeding one record, accumulated into a
SeedResult.Announces something by name: with
message, to every run waiting on that name and this
key; with signal, to every run listening for the name.Compiles and executes a
<send>: a message addressed to a name and a key, or a signal
addressed to a name alone, written to the Outbox; the walk continues.Mark the field to use a specified custom sequence.
The model a turn is served by: what data sent in the turn goes to.
Captures request metadata into the current session.
Incrementally builds structured session notes during a conversation.
Shows one data widget in a chat answer: runs a query as the user and returns its result with the
widget to draw it with.
Event fired on application shutdown
Convenience class for a
MenuNodeVisitorExports all skills to ai/skills/<code>/ entries (agentskills.io layout).
Seeds AiSkill records (agentskills.io layout) from ai/skills/<code>/ directories:
SKILL.md (frontmatter + instructions), references/*.md (text references), and
assets/* (binaries attached via DMS).Keeps the agent's skill catalog in the system prompt, and backfills skill content the history
does not carry.
Lookups shared by the skill tool and the chat plugin that injects skill content.
The default implementation of
MailAccount for SMPT accounts.Helpers for deriving
AiSources.Defines a password policy based on the required minimum number of special characters.
How a
<split> chooses among its flows, in BPMN terms: one (XOR, the first
matching flow, or the default), some (OR, every matching flow, or the default),
all (AND, every flow, unconditionally).A split.
Compiles and runs a
<split>: one continues to its first matching flow,
some forks into every matching flow and all into every flow.SSE implementation of
LoopEventSink.The workflow's entry and its trigger:
on (create, update, timer, manual) or
message, with when, watch, repeat, and delay/unit for a
timer.Event fired on application startup
Marker for direct clients that authenticate from the request itself and must never cause a
session to be created.
What a step's execution tells the walker to do next.
Stand down at a
<task> whose approval is already pending from an earlier run.An iterating
<call> wrote an activation and the run waits on it, with no key of its
own.Something inside a subflow's region had to wait.
Advance to a single next node.
The walk reached a plain end.
Fan out into every flow the split selected, in declaration order;
join is the barrier
the branches stop at.One flow the split activated: the id the author gave it, and where it leads.
Park at a node that waits: the run is left waiting rather than finished.
The walk reached a terminate end: this run is over, whatever else is still in flight.
Represents an interface for managing file storage.
Represents the type of storage used by a
Store implementation.Wire-format events for the AI SDK UI Message Stream Protocol v1.
Removes every part added since the most recent step boundary.
Builds a LangChain4j
StreamingChatModel from the DB-stored provider/model/agent config.Thrown by
ActiveStream.append(java.lang.String) when a run exceeds its buffer size cap.Subscriber side of one run: replays chunks from the cache, then tails until the run ends.
Writes
StreamEvents as SSE to an OutputStream.Deprecated.
Backed by
BytesEncryptor, which uses weak key derivation (PBKDF2WithHmacSHA1,
1024 iterations) and an instance-scoped salt.Coordinator that routes encrypt/decrypt operations between the legacy
StringEncryptor
($AES$), StringEncryptorPbkdf2Sha256 ($AESv1$), and StringEncryptorPbkdf2Sha512 ($AESv2$).AES encryptor operating on
String values using PBKDF2WithHmacSHA256 key derivation.AES encryptor operating on
String values using PBKDF2WithHmacSHA512 key derivation.The implementation of
Templates for the StringTemplate (ST4) support.This class provides static helper methods for
CharSequence.Represents a build job for a Studio project.
Controller for StudioBuildJob view actions.
Service for managing Studio project builds.
The class to map
StudioResource content.Service for deploying and undeploying Studio resources.
What a workflow deploy wrote, and the revision it displaced.
Service for exporting Studio resources to Gradle module format.
Service for processing and resolving files (data files, reports) attached to Studio resources.
Represents a data file with its resolved model information.
Represents a report file with its path information.
Studio schema for a workflow.
Utilities for meta views.
Service for managing Studio resources (CRUD operations).
Facade service for Studio operations.
A Studio tool: it reads or changes the application as the designer does, so the user must be
allowed to read or change Studio's resources.
Service for managing Studio resource versions.
A
WorkflowCatalog over Studio-authored workflows (the
StudioResource(type=WORKFLOW) rows within an app's dependency modules) unioned with deployed
MetaWorkflow rows.Converts a module-defined workflow's engine
<workflow> XML into Studio resource
content JSON — the inverse of the deploy path.Runtime guard against call recursion, for definitions loaded outside the save-time cycle check.
Runs the graph written inside it, in the caller's run: its nodes are its children.
Runs a
<call> or <subflow> over what its selector names: this record when none is
given, record, each element of each, or each row of filter.Pins the record a conversation is about.
Pinned fields resolved once per model and path for one reader: a chat listing shows many chats
pinned on the same few fields, and each resolve reads permissions and metadata.
A sync failure whose message is already fit to show an administrator.
JSON plumbing shared by the adapters, with failures phrased for an administrator rather than a
log.
What a sync did.
The admin-editable rules stored in
AiProvider.syncRules, deciding which of a provider's
models to take and what they can do.Extensible system tool registered via Guice Multibinder.
The record a session opens on.
Takes a named boundary on a parked approval for a message that matched its subscription.
A human task: the walk parks until a person completes it, then continues to
next.The
task a resumed graph reads after an approval closes: what was decided, by whom, and
on which pass.Compiles and executes a
<task>: the walk parks until a person completes the task, then
continues to next.The
Template interface defines methods to render the template.This interface defines API for template engine integration.
An
AxelorCache implementation that delegates to tenant-specific cache instances.A distributed variant of
TenantAwareCache that uses TTL-based expiry instead of closing
the cache on eviction.The contract to provide tenant connection settings.
The default implementation of
TenantConfig uses configuration provided from
axelor-config.properties.The contract to provide
TenantConfig.The default
TenantConfigProvider implementation.The tenant connection provider.
Custom converter for logback that outputs the current tenant identifier.
A Guice module to provide multi-tenancy support.
The tenant identifier resolver.
Titles a new chat once its first answer is in: a short model call over the user's message and the
reply, run after the stream ends so the reader never waits on it, and announced to the chat's
room like any other change.
A model call's tokens, meaning the same whichever provider served it.
Estimates token counts for
UIMessage lists using provider-specific tokenizers when
available, falling back to a character-based heuristic for providers without public tokenizers.Whether a tool may run, given who is on the other end of the turn.
Execution context passed to system tools.
Executes a tool by name and returns the result.
One call of a tool: its id in the conversation and, when it carries on after a confirmation it
asked for (
ToolResult.PendingConfirmation), the user's answer.Whether a tool must run inside the loop's JPA transaction, or outside it (e.g.
Exports AiTool records to ai/tools/
.yaml entries.Seeds AiTool records from ai/tools/<code>.yaml files.
Deduplicates a repeated tool call within a single stream request.
Result of a tool execution — either success with output or an error.
The tool should be executed client-side (in the browser).
The current agent wants to consult a sub-agent.
The tool requires user approval before execution.
The tool stopped at a question only the user can answer — a form's alert, a button's prompt —
and will carry on from where it stopped once they answer.
Safety classification for tools, determining approval behavior.
This annotation can be used on
Model classes to provide change track details.The change track event types.
This annotation can be used to specify details about field for change tracking.
This annotation can be used to specify custom change tracking messages.
How a workflow fires (
<start on>); the bound counterpart of the stored WorkflowTrigger.Runs an agent on a request a user would make, as a trial (see
ChatRequest.trial): its
writes run and are undone, and the builder reads back the answer and every call the agent made,
with what each returned or why it failed.Accumulator for one assistant turn.
A message in the conversation history.
The sender of a message.
A part within a
UIMessage.One record of a batch update — the singular parameters, per record.
Defines a password policy based on the required minimum number of uppercase characters.
Build and manipulate URLs
Every usage policy, as
UsagePolicyImportService reads them.Usage policies from YAML, one file each, keyed by
name.This object stores the users.
Parses raw User-Agent header strings into structured
UserAgentParser.UserAgentInfo objects.Structured representation of a parsed User-Agent string.
Represents an authentication event of a user, for display.
User service
Represents an active user session
Device and network information
Service for managing API tokens for user authentication.
Activates a skill to load its full instructions, or fetches a specific reference within it.
Utility class for generating and handling UUIDs (Universally Unique Identifiers).
Enum type fields with custom values should implement this interface.
One frame of a run's variables, and the frame it sits inside.
The values and assignment counts at the start of one branch's walk.
One model as a provider's list endpoint reported it, normalised by its adapter.
Provides helper methods to find version information of axelor projects.
This class stores version details of axelor modules.
One validation finding: a stable
code (<element>-<attr>-<problem>), the
translated message, and the nodeId it is about, or null for a workflow-level
rule.This annotation should be used to mark computed fields.
The walk parks here until a timer elapses (
delay + unit, or until), a
condition holds (when), or a message with a key, or a signal,
arrives; then it continues to next.Compiles and executes a
<wait>: parks until its timer is due, its condition holds or its
message arrives, with the boundaries on it racing that trigger.What a walk reads as
agent, task and error: the last of each on its path.Provides information about UI widget representing this field.
One workflow definition.
SPI for invoking an AI agent from an
<agent> node, bound by the AI module.The AI implementation of the workflow
<agent> node SPI.Wakes the run parked on a
<call> once the child it started has finished or terminated.Which workflows exist and what each references: what
WorkflowLinker resolves against.A workflow identity:
(model, jsonModel, name); jsonModel may be null.Compiles a parsed
Workflow into an immutable WorkflowPlan: the structural gate
the runtime relies on (one start, unique ids, every edge resolving, joins paired with their
splits).Evaluates a workflow
when predicate in a sandbox.The tenant and acting user, read from the ambient context where they are used rather than carried
on events: every thread that runs workflow logic is already bound to the right ones.
A scope opened by one of the methods below; closing it ends that scope on the thread.
Remembers the XML a
MetaWorkflow row is about to lose.Which workflows are deployed, and which of them apply to a given record, trigger or message.
Detection-only listener for deletions: records which rows went and, after commit, hands them to
WorkflowRecordCleanup.Marks a capture before execution can produce effects outside its database transaction.
SPI for template-based workflow email.
An expected template generation or queue-submission failure that a workflow may catch.
The way into the engine from application code: run a workflow from an action, a service or a REST
call, on the caller's thread, and return what happened.
Lock-free workflow metrics published as a read-only platform MXBean.
Read-only, node-local operational view of the workflow engine.
A captured change handed to the runtime.
Detection-only listener: during flush it captures the model, the changed fields and before/after
snapshots (custom fields flattened), and never runs workflow logic, queries or saves.
Walks a workflow's graph for one record.
What a body's walk left: where it got to, and the frame it opened.
Small syntactic helpers shared by the code that scans workflow
when expressions.A node failed.
Builds a
WorkflowGraphView from a workflow's stored XML, so module XML draws as well as
designer-authored definitions.Compiles stored workflow XML into an immutable plan, cached by XML content.
Render-ready, sanitized view of a workflow's graph, built by
WorkflowGraphBuilder.One link.
One node, as the viewer draws it.
One point of an edge's route, as numbers: a decimal would reach the client as a string.
Restores workflow user attribution on scheduler and capture-dispatch threads.
What happens when a branch of a split finishes: the counting, the cleanup of losing branches, and
the one continuation past the join.
Starts one definition on one record: the re-entrancy key, the run, and a
once workflow's
budget, spent only when the run fired.The cross-workflow checks: every
<call> ref resolves, and no chain of calls returns to
where it started, resolved through a WorkflowCatalog.Registers the workflow detection listeners: saves that may trigger, deletes that must clean,
definition changes whose previous graph has to be remembered before it is gone, and the updates a
resumed walk makes.
Offers sent messages to whatever is waiting for them; the scheduler decides when.
Applies the operator's decisions: the write half of the parked-run mover.
Common type for all nodes in a workflow graph.
After-commit orchestration for a captured create or update: resolve the eligible workflows, apply
watch and repeat policy, launch the ones that fire and arm timer workflows.A failure retrying cannot fix, typically a definition changed under something parked on it.
The immutable compiled form of a workflow, produced by
WorkflowCompiler.Invokes an AI agent with
prompt and binds the answer as agent.A compiled
<boundary>: one way out of its host and where to continue.Where a child graph comes from:
WorkflowPlan.Callee.Ref names another definition, resolved when the node
runs; WorkflowPlan.Callee.Inline carries the body's plan, compiled with the caller and so pinned to its
revision.model/jsonModel are what the body declared, or null for unchecked elements.A
<call>: runs the workflow named ref as a child run.A template-based email for the workflow record, with its error boundaries.
The walk stops here.
A
<call> or <subflow>: a child graph run over a selection.A join's completion policy:
All waits for every selected branch to arrive or end,
Quorum(n) for the first n arrivals, cancelling the rest (n=1 is
any).A join: the
some/all split it closes and its completion policy.Runs a script body against the record context; it may create and save records.
What a call or subflow runs on: at most one of
record, each and filter,
none meaning this record.A compiled
<send>: a message (name and key) or a signal (name alone), and where the
walk goes next.A split.
The start node's firing configuration.
A compiled node.
A
<subflow>: runs its embedded body inside this run.A human task.
Which graph a run or branch walks, resolved for a whole dispatch in one query rather than one per
run.
Whether the caller may read the business record a task, run or approval is about.
Fired after a transaction that changed a record's pending approvals, or resumed one of its runs
off the request that saved it, commits.
Ends what the engine still holds for deleted records: pending approvals, parked runs and trigger
state.
Collects record change notifications during a transaction and fires them as
WorkflowRecordChanged only after it commits, deduplicated per record, so listeners that re-query
never read pre-commit state.Guards against runaway cascades: a run may save records whose events start more runs.
A resolved workflow: the stored row paired with its compiled, immutable plan.
Resolves the ordered workflows eligible for a model and trigger: each
(model, jsonModel,
name) collapses to its highest-priority active definition, ordered by sequence, then id.What a workflow is bound to: an entity class, plus the custom model when that class is
MetaJsonRecord.How one walk of a workflow graph ended.
A failure the definition raised on purpose;
code is null when it named none.Compiles a definition, runs its graph, times it and records the outcome: the one run-and-record
path for automatic and programmatic runs.
Persists workflow run history.
One run, as the viewer draws it: the definition's shape, where the run has been, and where it is
now.
One activation of one split.
One branch of an activation.
One escape branch this run spawned, read under the same access check as the run.
Somewhere the run is stopped right now; a fork has one per outstanding branch.
The nodes a run passed and the edges it took, each within its graph; a node or edge is on it if
any thread went that way.
An edge on the path, as the graph draws it.
A node on the path;
nodePath is the subflow it is in, null for the definition's.One pass through a node; a loop yields several.
Assembles the viewer's answer for one run.
Root container for a module workflow file:
<workflows> holding many <workflow>.The engine's cluster-safe scheduler and its one threading seam.
The run-independent helper bindings shared by every workflow script.
Builds the flat field snapshot a
when evaluates against: the entity's persistent scalars
plus its custom fields flattened to top-level keys, real fields winning on a collision.Writes down where a split's branches got to once one of them has to wait.
Where one branch got to when the walk stopped for the split.
What a region's branch walks: the record bound to its
self and the frame its body
opened.A split one branch ran into, carried up the stack until that branch has a row for it to hang
from, then written right after its parent.
The park watching a whole region, resolved as the walk entered it:
enteredAt is the
entry, which is what its deadlines run from.Starts runs because a message named them: the message's key is read as the id of a record of the
definition's own model.
A concurrent caller created this state row first: a benign race whose loser rolls back and
skips.
Thrown by
WorkflowTaskService.complete(java.lang.Long, java.lang.String, com.axelor.auth.db.User) while a task's when is false.What the approval inbox reads: which tasks a user may act on, the rows of a record's approvals
dropdown, which buttons a task offers, and why one is out of reach.
The actionable-by-me domain and the role and group ids it binds.
Claims, completes and governs approvals, resuming the parked workflow when one closes.
Renders a prompt template: each
${expr} span is replaced by what eval
returns, and all other text is copied verbatim.How much execution history the engine keeps, from
workflow.trace.Semantic validation of a parsed
Workflow, beyond the XSD and the compiler's structure:
models exist, triggers are coherent, watch covers when, expressions parse, and the graph
terminates.The engine's one value codec: guest values from a script (
WorkflowValues.fromValue(org.graalvm.polyglot.Value)), and host values to
and from JSON (WorkflowValues.encode(java.lang.Object, java.lang.String, com.axelor.workflow.expression.WorkflowValues.HostPolicy) / WorkflowValues.decode(java.lang.Object, com.axelor.workflow.expression.WorkflowValues.TagPolicy)).What to do with a host object
WorkflowValues.encode(java.lang.Object, java.lang.String, com.axelor.workflow.expression.WorkflowValues.HostPolicy) cannot turn into JSON: a message refuses one, a
variable stores a reference.What a caller makes of a tag this codec does not recognise.
The value policy for
vars: what a run's variables may hold and how they go to and from
the run's row.A workflow refused at a save boundary.
Resumes parked runs and branches: timer waits on the scheduler's wake (
WorkflowWaitService.resumeTimer(java.lang.Long)),
condition waits when their record changes (WorkflowWaitService.resumeConditionWaitsForRecord(com.axelor.workflow.exec.RecordRef)), message waits
on delivery, and a caller parked on a <call> when its child finishes (WorkflowWaitService.resumeCaller(com.axelor.meta.db.MetaWorkflowRun)).The one way the AI checks a write: every field it sets must be one the user may write.
XML data importer.
The
XMLUtils provides various methods to deal with XML parsing.JAXB binding entry point for workflow definitions.
Nested-YAML parse/dump plus typed accessors, for config-shaped seed files.
This class defines from static helper methods to deal with YAML.
Zips a map of relative-path → bytes into a single archive.
Reads seed entries from a zip stream.