All Classes and Interfaces
Class
Description
Declares which roles may read and write an entity.
What a custom action handler receives when invoked: the entity it ran on, (for row/detail
actions) the record's id, and the current values of any toolbar
inputs.Runs a custom
ActionSpec server handler for an entity.Per-action placement builder for a document's detail-header actions
(
post / unpost / edit / delete): show it as a
primary button, tuck it into the overflow (⋯) menu, or hide it entirely.What the client does after a server-side action runs: optionally show a message, navigate to a
route, and/or refresh the current surface.
A read-only view of one list row, handed to the per-row functions of a row
action (.icon(...), .label(...), .visibleWhen(...),
.enabledWhen(...)) so a single control can vary by that row's state — a pause
"Suspend" on a running record flipping to a play "Resume" when it's stopped, or a button
shown only on the rows it applies to.Where a custom
action button appears.Declares custom action buttons for an entity, from
EntityView.actions(ActionSpec).A resolved action button.
Fluent builder for one action; setters may be called in any order.
A one-time, versioned data migration — the home for backfills, data reshaping and seed
data that the automatic schema upgrader cannot derive from metadata.
Declarative validation bounds for an attribute, from
@Attribute.Enforces the declarative
@Attribute constraints (required, string length, numeric
min/max, regex pattern, email) on an entity before write, collecting every failure into a
ValidationErrors keyed by field name.Describes how a user may authenticate, so the login screen can be composed server-side rather than
hardcoded in the client.
Additively contributes SSO options to the login screen, on top of whatever the single
AuthMethodsProvider already offers.Supplies the
AuthMethods for the running application.Declarative back-office branding for a
Layout's shell: an explicit app
name, a logo (with an optional dark-mode variant), a favicon, and brand color
overrides for the light and dark BrandPalettes.A consumer's brand color overrides for one mode (light or dark).
A named validation rule expressed as typed Java — the replacement for the old
@BusinessRule(expression = "...") string mini-language.Evaluates a
Validated entity's typed BusinessRules before write and before
posting.Write-side commands for catalogs — create, update, delete.
Read-side queries for catalogs, shared by the REST API and the DivKit emitters
so the SQL and ref-resolution live in one place.
Publish side of cross-node live-UI sync: forwards every locally-originated
EntityChangedEvent
onto the ClusterEventBus so peer nodes can fan it out to their own SSE clients.Wire form of a cross-node change notice carried by a
ClusterEventBus.Pluggable SPI for delivering
ClusterEvents across the nodes of a horizontally-scaled
deployment — the mechanism that keeps live-UI updates in sync when more than one instance runs
behind a load balancer.Receive side of cross-node live-UI sync: subscribes to the
ClusterEventBus and pushes events
that originated on other nodes to this node's SSE clients via
UiEventPublisher.publish(String, String, String, Object, String).Desired state of a single column, derived from metadata.
One stored comment in the
onec_comments thread of a single entity.Resolves comment authors' avatar image URLs, live, from the identity catalog — the one the login
links to via
UiIdentityLink (e.g.The discussion-thread endpoint.
The request body for posting a comment.
Configuration for the
/api/comments discussion-thread feature, under the
onec.comments.* namespace.Wires the
/api/comments discussion-thread endpoint, its CommentService store, and
the onec.comments.* configuration.Persistence for
onec_comments: the framework-owned thread store behind the
/api/comments endpoint.Failover dispatcher (
provider=failover).Materializes the deferred CSRF token on every request so the
XSRF-TOKEN cookie is
present after the first response to a fresh client.Resolves the authenticated principal to a domain catalog record via the
configured
UiIdentityLink (e.g.Builds the home/dashboard content div: a greeting header and the widget area.
Deprecated, for removal: This API element is subject to removal in a future version.
Reads the live database structure (tables and their columns) from
INFORMATION_SCHEMA, which both H2 and PostgreSQL expose.Live tables and columns, keyed by upper-cased table name.
An authored desktop shell — the structural peer of
Layout.When the shell launches the JVM it passes
--onec.desktop.home=<dir>
pointing at the OS per-user app-data directory.The immutable window description the Tauri shell fetches from
/api/desktop/manifest at boot.The two endpoints the Tauri shell drives at launch:
GET /api/desktop/ready — returns 200 once the context is up, so
the shell knows when to swap the splash for the real window.Infrastructure toggles for desktop mode.
The builder a
DesktopApp configures.System-tray builder.
Window geometry builder.
Factories + fluent styling helpers for real DivKit div nodes, emitted as plain
maps so Jackson serializes them to the DivKit JSON schema (
"type":
"container" | "text" | "gallery" | "image" | "separator" | ...).Wraps a root div in the DivKit document envelope
(
{ templates, card: { log_id, states: [{ state_id, div }] } })
that every official DivKit renderer (Web, iOS, Android, Flutter) consumes.Emits the server-rendered DivKit app, split so the client can render instantly
and load data lazily:
/shell returns the chrome (top bar + nav, no data
— fast), and each content endpoint returns just that surface's card.Write-side commands for documents — create, update, delete, post, unpost — plus
the document reconstruction needed for posting.
Published after a document has been successfully posted and its posting transaction has
committed (movements written, balances checked,
_posted flipped).Read-side queries for documents (list with optional date range; detail with
tabular sections), shared by the REST API and the DivKit emitters.
Published after a document has been unposted and its unpost transaction has committed
(register movements reversed/deactivated,
_posted cleared).Published whenever a catalog or document changes, regardless of which write path made the change —
the generic REST controllers (raw JDBI) and
repository.save(...) (Spring Data JDBC) both
emit it, so server-side listeners see every change, not just back-office edits (issues
#28, #29).Narrow SPI the framework-starter write callbacks use to emit
EntityChangedEvents after a
repository.save(...)/delete(...).Per-entity configuration scope passed to lambdas on
SectionBuilder.catalog/document/register.A query-layer view over a single queryable entity (catalog / document / register),
unifying the per-kind descriptors behind one shape: table name, primary-key column,
the built-in system columns, and the user attributes.
Per-entity UI definition, authored in code and discovered as a Spring bean —
the "view" layer of the framework.
Maps
@Enumeration constants to/from their deterministic UUID ids.Spring Data JDBC converters that bridge our value-object types (
Ref and framework enums)
and the UUID columns emitted by the schema generator.Application-defined handler for inbound CloudEvents.
UI hints for a single field, configured via
UiLayoutBuilder.Per-field hint builder.
Per-entity field hints, authored on each
EntityView.fields(com.onec.ui.EntityConfigBuilder) and resolved
by class.Dev dispatcher (
provider=file).The default
MediaStorage: streams uploads to a directory tree on disk and serves them
back through GET /api/media/{key}.Universal provider adapter (
provider=http).Exposed to templates as
json; renders a value as a quoted, escaped JSON literal.A decoded inbound CloudEvent delivered to
EventHandlers.Routes a decoded
InboundEvent to every EventHandler that supports its type.Idempotency ledger for inbound CloudEvents.
Read-side queries for information registers, used to drive related-list panels backed by a
register junction (see
RelatedList, Junctions).Declares custom input fields for an entity's list toolbar, from
EntityView.inputs(InputSpec).Fluent builder for one input; setters may be called in any order.
A resolved toolbar input field.
The kind of toolbar input field rendered alongside the custom action buttons.
Kafka message listener that decodes the CloudEvents envelope, de-duplicates via the
Inbox,
and dispatches to application EventHandlers through the InboundEventRouter.An authored layout — the structural peer of
Page and EntityView.The builder a
Layout configures: navigation sections (with per-field
hints), the shell/nav presentation, branding, identity link, and — for persona
layouts — the target roles and match priority.Serves pages of list data to the virtualized list grid (the
onec-list React island).Compiles the
onec-list grid's declarative filter values (sent by the React island as
eq/in/like/prefix/ge/le query params) into a safe
SQL fragment with bound parameters.A compiled predicate: a
WHERE-ready fragment (no leading AND) and its bindings.Builder for an entity's list/table surface, used inside
EntityView.list(com.onec.ui.ListSpec).A resolved list filter: the bound field, its label, the control type and — for the
ListSpec.FilterType.OPTIONS/ListSpec.FilterType.MULTI_OPTIONS controls — its choices.Fluent builder for one filter;
ListSpec.FilterBuilder.options/ListSpec.FilterBuilder.multiOptions(java.lang.String...)/ListSpec.FilterBuilder.contains()/
ListSpec.FilterBuilder.startsWith()/ListSpec.FilterBuilder.dateRange() pick the control type.How a filter narrows the list query (and which control the grid renders).
A stored binary read back for serving, returned from
MediaStorage.load(java.lang.String).Dev dispatcher (
provider=log).Builds the server-driven login screen as a DivKit card from the available
AuthMethods.Serves the server-driven (DivKit) login screen at
GET /api/divkit/login.Provider SPI.
Inbound delivery-event webhook (enabled via
onec.mail.webhook.enabled=true).Provider-agnostic outbound mail message.
Side-effect queue for outbound mail.
Drives
MailOutboxRelay.relayPending() on a fixed delay so queued mail actually leaves the outbox.Dev-only endpoints (enabled via
onec.mail.preview.enabled=true) for inspecting templates:
a JSON listing of every registered template, and an in-browser HTML render of one by name using a
best-effort sample instance of its target type.Config for the
failover composite dispatcher: tries each named provider in order.Config for the
file dev dispatcher, which writes messages to disk instead of sending.Config for the universal
http dispatcher: POSTs a rendered JSON body to any provider's REST API.Dev-only HTTP endpoints for listing and rendering templates.
Background relay that drains the outbox on a fixed schedule.
Inbound provider webhook (bounces/complaints) that feeds the suppression list.
Renders mail subject and body templates.
High-level mail facade.
Addresses that must not be mailed: hard bounces, spam complaints, and explicit unsubscribes.
Declares a mail template attached to a document or catalog class.
Bridges the authenticated Spring Security principal into the MCP tool-call context.
Contributes a dedicated, high-precedence
SecurityFilterChain scoped to the MCP
endpoint.Wires the
/api/media binary-upload endpoint and its default filesystem storage.The framework's binary ingestion endpoint.
Configuration for the
/api/media binary-upload endpoint and its storage backend, under
the onec.media.* namespace.Pluggable backend for binary uploads — the SPI behind
POST /api/media.Generates the MCP tool set generically from the
MetadataRegistry.Everything an
AppMigration gets to work with: a JDBI Handle bound to the
transaction the migration (and its history record) runs in, the metadata registry for
resolving table/column names from entity metadata, and the active SQL dialect.The ordered set of changes that would bring the database in line with the metadata.
Executes
AppMigrations exactly once per database, in version order.How the app's navigation chrome presents.
Local-only
ClusterEventBus used when no cross-node transport is configured — a single-node
deployment, a non-Postgres (e.g.Marks freshly-loaded aggregates as not-new so that a subsequent
repository.save(...)
issues an UPDATE rather than an INSERT.Auto-configures authentication for an Onec application.
OIDC configuration for the
OnecAuthProperties.Mode.OIDC and OnecAuthProperties.Mode.RESOURCE_SERVER modes.Provider presets.
Persistent "remember me" login for
OnecAuthProperties.Mode.IN_MEMORY.Effective OIDC settings after the
OnecAuthProperties.Provider preset has been applied.How token claims map onto Spring Security authorities.
One claim that carries roles, and the shape of its value.
Session longevity for the cookie-based modes.
The shape of a role claim's value.
Excludes Spring Boot's default JdbcRepositoriesAutoConfiguration since
OnecRepositoriesAutoConfiguration handles JDBC repos with proper RegisterRepository exclusion.
The onec-framework version this build was produced from, baked into
META-INF/onec-build.properties by the processResources step.Wires desktop mode: exposes the manifest/readiness endpoints the Tauri shell
drives, and supplies a default
DesktopApp when the application defines
none.A
MappingJdbcConverter that fixes how framework enums map onto their database column type.Inbound (consumer) settings.
Auto-configuration for the onec MCP server.
Configuration for the onec MCP server.
JDK Flight Recorder instrumentation helpers for onec framework operations.
Schema lifecycle configuration (
onec.schema.*).Security-related configuration (
onec.security.*).Replaces Spring Boot's JdbcRepositoriesAutoConfiguration with one that excludes
RegisterRepository subtypes, and enables register repo scanning separately.
Maps the framework's
ValidationException (a missing required attribute, an out-of-range /
malformed value, or a failed business rule) to HTTP 400 with a small JSON body, so a client-input
error reads as a Bad Request instead of a 500 (issue #32).An ORDER BY term over a
Path.An authored page — a route whose content you compose in code, the page-level
peer of
EntityView.Composes a
Page's content: an optional header, a grid of dashboard
widgets, and freeform PageComponent blocks.A freeform block a
Page composes beyond the widget grid: a text block, a
div-custom extension, a full interactive entity list, or a section of action buttons.Renders an authored
Page to DivKit content: a header, the
composed widget area, then any freeform PageComponent blocks.Theme-aware color palette mirroring the app's shadcn CSS variables (a neutral,
zero-saturation scale) so emitted DivKit surfaces match the rest of the UI in
light and dark.
A column reference within a query, expressed as a chain of bean-property hops on
the query's
from entity.Narrow SPI the
PostingEngine uses to emit DocumentPostedEvent/
DocumentUnpostedEvent after a post/unpost transaction commits.ClusterEventBus backed by Postgres LISTEN/NOTIFY — the default cross-node
transport, needing no infrastructure beyond the database the app already uses.Posts documents: runs their
Postable logic, writes the resulting register movements and
totals, enforces non-negative balances, then flips _posted.A WHERE condition on a
Path.Renders a registered template for a given target object into bytes.
Declares a print template attached to a document or catalog class.
Static factory helpers for the fluent query DSL.
Fluent front-end that accumulates a
QuerySpec and runs it through a
QueryEngine.Compiles a
QuerySpec to SQL via the JoinWalker (ref-navigation joins)
and the shared SqlRenderer, then runs it through JDBI.The declarative AST for a query over any catalog, document, or register — the
single source of truth that the fluent builder produces and that the engine compiles
to SQL.
Resolves Ref UUID columns and Enum UUID columns to human-readable display values.
Read-side queries for accumulation registers (movements, balance, turnover),
shared by the REST API and the DivKit emitters.
Scans for RegisterRepository interfaces and ensures they are registered
with RegisterRepositoryFactoryBean, replacing any JDBC-created definitions.
A declarative related-list (inline child rows) panel for a catalog or document view,
backed by a junction — a join catalog or an information register — rather than an owned
tabular section.
Builds one
RelatedList panel for a catalog editor.Resolves and reads the rows of a related-list panel for any owning entity — catalog
or document — over any junction — join catalog or information register.
Renderer-agnostic resolved list surface: a title and ordered columns.
A resolved column: the header label, the data column it reads, an optional width hint
(e.g.
A resolved list filter: a stable
key (the field name, the client's state key), the
label, the data columnName the query filters on (resolved + validated against
the entity's columns), the control type ("options", "multiOptions",
"contains", "startsWith" or "dateRange") and, for the (multi-)options
controls, its options.Resolves descriptor metadata into a JSON-shaped attribute view, merging field
hints over descriptor defaults.
An untyped projection row — the default result of a join/aggregate query, since a
join result is not an entity.
One change in a
MigrationPlan: what it is, the SQL that performs it, and whether
it can lose data (destructive changes are skipped unless
onec.schema.allow-destructive=true).Computes the
MigrationPlan that brings the live database in line with the
metadata-derived SchemaModel.Renders
CREATE TABLE IF NOT EXISTS DDL for everything in the metadata registry.Persistence for
onec_schema_history: one row per applied schema change-set
(kind SCHEMA, carrying the metadata snapshot and the DDL that was executed)
and one row per executed AppMigration (kind MIGRATION,
claimed via a unique constraint so concurrent instances run each migration exactly once).Additive-only schema evolution: adds columns that exist in the metadata model but not in
the live database.
How the framework treats schema differences at startup (
onec.schema.mode).The full desired database state derived from the
MetadataRegistry:
framework tables (sequences, outbox) plus one TableModel per catalog, document,
tabular section, register, enumeration and the constants table.Builds the desired
SchemaModel from the metadata registry.A point-in-time record of the metadata-derived schema, persisted as JSON in
onec_schema_history.Startup schema lifecycle: scans nothing itself — it takes the already-built
MetadataRegistry, derives the desired SchemaModel, diffs it against the
live database (and the previous SchemaSnapshot from onec_schema_history),
and then acts according to SchemaMode.Encrypts/decrypts
@Attribute(secret = true) values at rest with AES-256-GCM.Applies a transform to the secret String fields of a typed catalog/document aggregate.
Strips
@Attribute(secret = true) values out of read responses so the generic API is
write-only for secrets.One item in the SELECT list: a
Path (plain column or ref-navigation),
optionally wrapped in an aggregate, with an output alias used as the result-Row
key and the fetchInto property name.Ensures the Spring Session JDBC schema exists on persistent databases.
App settings backed by the framework's
Constants.App-shell presentation config: the
NavStyle this layout's navigation
uses, plus the consumer's BrandingConfig (app name, logo, favicon, brand
palette).Emits the app chrome as two independent DivKit cards — the
topbar (brand
+ actions) and the nav — so the client can position them per
NavStyle: nav as a horizontal TOPBAR, a vertical SIDEBAR
rail, or a pinned BOTTOM_BAR.A branding logo for the shell header / mobile menu: the (theme-resolved) image
URL plus optional fixed
width/height in dp.Identifies the target database so upsert helpers can emit portable SQL.
The shared
SELECT … FROM … JOIN … WHERE … GROUP BY … ORDER BY assembler.Pre-rendered SQL fragments for one statement.
A single sign-on option offered on the login screen — one OIDC client registration.
A reference to a stored binary, returned from
MediaStorage.store(java.io.InputStream, java.lang.String, java.lang.String, long) and serialized as the
JSON body of POST /api/media.Builds the per-surface DivKit content (catalog/document lists, document
detail, register report) from the resolved metadata view + data rows.
One detail-header action.
Desired state of a single table, derived from metadata.
Collects the custom
actions and toolbar inputs declared by
every EntityView, indexed by entity class.Pushes entity-change notifications to browser
SseEmitters for live UI updates.Deprecated, for removal: This API element is subject to removal in a future version.
Configure field hints in an
EntityView or Layout
bean instead, e.g.Links an authenticated account to a domain catalog record (e.g.
A named persona bundle: its own navigation (
sections), home
(widgets), branding (title/theme) and the
roles that resolve into it.Typed brand color overrides for one mode; unset slots stay
null (renderer default).Configures a named persona profile.
Builds the
ShellConfig — this layout's navigation presentation and
BrandingConfig (app name, logo, favicon, brand palette).Resolves which
UiLayout.Profile a user sees, by matching their roles
against each named profile's target roles.The built-in Settings page — the
@Constant editor surfaced at /settings with
an auto-injected admin nav entry.Deprecated, for removal: This API element is subject to removal in a future version.
Assign entities to sidebar sections in a
Layout bean
instead, e.g.Resolves a per-entity
EntityView (authored in code) over the
auto-generated metadata defaults into a renderer-agnostic ResolvedListView.Periodically asks onec-cloud for the latest published framework version and, when it is newer than
the running one, flips
UpdateChecker.status() to "update available" — which the web client reads off
/api/config and renders as a dismissible banner.Configures the "update available" check: the running app periodically asks onec-cloud what the
latest published framework version is and surfaces a notice when it is newer than its own.
The last-known result of the update check, exposed to the web client via
/api/config.A document/catalog that declares typed validation rules, checked before write
and before posting.
Accumulates validation failures across all sources (declarative attribute constraints, custom
BusinessRules) so the user sees every problem at once rather than one at a
time.Thrown when an entity fails framework validation on the write path — a missing required
attribute, an out-of-range / malformed value, or a failed
BusinessRule.The device class a client reports for itself, so the framework can serve a
layout and page composition tailored to it.
Builds the SQL aggregate expression for a count/metric card.
Parses an authored count/metric-card
filter predicate into a safe SQL
fragment with bound parameters.A compiled predicate: a
WHERE-ready fragment (no leading AND) and its bindings.Validates a generic catalog/document write before it persists.
Pagebean instead, e.g.