Skip to content
CAI
Software that uses CAICheck a score

apache/causeway

39.8

Weak · 22 October 2026

332.9k

lines of production code

Java

with JavaScript

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Apache Causeway is a Java-based framework for building domain-driven applications by automatically generating user interfaces from domain models. It supports multiple viewers, including Wicket, RESTful Objects, GraphQL, and modern web components, while providing a modular architecture for persistence, security, and extensions. The system facilitates rapid development through features like command replay, audit trails, and rich value types, all managed within a Spring Boot environment.

How it got here

2004–2022 — Apache Causeway v2.0 migration and modularization

152 changes.

This period marks the comprehensive migration of the Apache Isis project to Apache Causeway, involving a major rebranding and architectural overhaul to version 2.0. The work focused on restructuring the codebase into modular Java components, migrating persistence from JDO to JPA with Jakarta EE namespaces, and modernizing the REST viewer with Spring Boot and Jackson 3. It also established a new Antora-based documentation site and expanded the framework with new value types, security integrations, and testing utilities.

2023–2025 — GraphQL viewer and extensive regression testing

67 changes.

This period focused on introducing a modular GraphQL viewer with configurable schema strategies and expanding the framework's extension ecosystem with features like FullCalendar, GitHub layout loading, and PDF/Excel exports. A massive effort was dedicated to building a comprehensive regression test suite, covering JPA persistence, Wicket and RESTful viewers, and core domain model validation to ensure stability across the platform.

2026 — WebComponents viewer and OpenSpec workflow

19 changes.

This period focused on establishing a declarative web component foundation for the Causeway viewer, implementing generic HTMX and Vue-based viewers with SecMan authentication, and providing sample applications to demonstrate these capabilities. Concurrently, the project introduced the OpenSpec workflow to standardize AI agent skills and operational standards, while also adding foundational command replay infrastructure and regression tests for tracing compatibility.

Features

Add local SecMan authentication for HTMX webcomponents viewer

This change introduces a new security module for the HTMX webcomponents viewer that enables local authentication using Spring Security's SecMan provider. It adds a complete authentication flow including an entry point that handles HX-Request headers for seamless redirects, success and failure handlers that manage the 'continue' parameter for post-login navigation, and a security configuration that enforces CSRF protection and defines specific paths for login, logout, and GraphQL endpoints. A validator ensures that required configuration properties are set correctly, and an authentication shell exposes the current user state and CSRF tokens to the frontend.

causeway-viewer-webcomponents-htmx-security-secman · high confidence

Add secured Vue Petclinic sample application

A new secured variant of the Vue Petclinic sample application is now available, providing a complete Spring Boot backend and Vue.js frontend for demonstration purposes. The application includes a Java entry point that configures the Causeway runtime with JPA persistence, GraphQL viewing, and security bypass presets, alongside a route controller to serve the Vue single-page application. The frontend assets include a custom CSS theme with light and dark mode support and a JavaScript bundle implementing the Vue 3 runtime, enabling users to run and inspect a fully functional, secured webcomponents-based sample.

viewers/webcomponents/sample-vue-petclinic · high confidence

Added Algolia search configuration files

New configuration files for Algolia search indexing have been added to the documentation attachments. The \algolia-config.json\ file defines the indexing scope for the Apache Causeway website, specifying start and stop URLs to exclude specific documentation versions and paths, and configuring selectors to extract page hierarchy and text content. The accompanying \algolia.env\ file provides the necessary application ID and API key for the search service integration.

antora/components/comguide/modules/ROOT/attachments · high confidence

Added Gradle wrapper configuration

The project now includes a Gradle wrapper configuration file (gradle-wrapper.properties) that specifies the use of Gradle version 6.5.1. This allows users to build the project using a consistent, self-contained Gradle distribution without needing to install Gradle globally.

gradle · high confidence

Added H2 Console UI module for prototyping environments

This change introduces a new testing module that integrates the H2 database web console into Apache Causeway applications running in prototyping mode. It registers a secondary menu item named 'Prototyping' containing an 'H2 Console' action, which opens the database management interface at the /db path. The module automatically detects H2 in-memory data sources, configures the servlet with a random admin password if enabled, and restricts access to local connections by default to ensure security during development.

testing/h2console/ui · high confidence

Added HSQLDB Manager prototyping tool

Added a new prototyping menu item named 'HSQL DB Manager' that launches the HSQLDB Swing database manager for in-memory databases. This feature is restricted to prototyping environments and automatically detects available HSQLDB in-memory data sources to configure the connection URL.

testing/hsqldbmgr/ui · high confidence

Added JobExecutionData helper for Quartz job data access

A new JobExecutionData class has been introduced to simplify interaction with Quartz job execution contexts. This utility provides methods to safely retrieve and store string properties within the job's data map, handling potential exceptions during retrieval to ensure robustness.

causeway-extensions-commandreplay-secondary · high confidence

Added Server-Sent Events (SSE) Wicket web module

The causeway-extensions-sse-wicket module now includes a new WebModule implementation that registers a Servlet for Server-Sent Events at the /sse endpoint. This enables real-time event streaming capabilities within Wicket-based applications through the standard Causeway web module lifecycle.

causeway-extensions-sse-wicket · high confidence

Adds Caffeine-based title caching extension

Introduces a new Caffeine-backed implementation for the title cache extension, replacing the previous JCache-based approach. This module registers a Spring configuration that sets up a CaffeineCacheManager with default settings of a 10-minute write expiry and a maximum size of 100 entries. The TitleCacheSubscriber service listens for title computation events and populates the cache, allowing applications to benefit from faster title retrieval using the Caffeine library instead of the generic JCache API.

extensions/core/titlecache/caffeine · high confidence

Adds JPA persistence support for Vega value types

This change introduces the \persistence-jpa\ module for the Vega value type, providing automatic database persistence via a JPA \AttributeConverter\. The module registers \CausewayVegaConverter\ to transparently serialize \Vega\ objects to and from \String\ columns in the database, and configures Spring Boot to scan for this converter automatically.

valuetypes/vega/persistence-jpa · high confidence

Adds JPA-specific Querydsl integration module

The persistence/querydsl/jpa module now provides the concrete JPA implementation for the Querydsl integration layer. This includes a Spring Boot auto-configuration module that wires up the JPA-specific services, a factory for creating detached queries using JPA Querydsl, and a support component that bridges the application's query DSL abstractions to the underlying JPA EntityManager and JPAQueryFactory. This enables applications using JPA to leverage Querydsl for type-safe queries within the Causeway framework.

persistence/querydsl/jpa · high confidence

Adds ability to re-publish execution log entries to the outbox

The Execution Republisher extension now contributes a 'Copy to Outbox' action to Execution Log entries. This allows users to manually re-publish a specific execution from the log to the outbox, facilitating reprocessing when downstream handling of an outbox item previously failed.

extensions/core/executionrepublisher/applib · high confidence

Adds core documentation and configuration generation infrastructure

This change introduces new files to support the core module's documentation and configuration management. It adds an Antora site definition (\core/adoc/antora.yml\) for design docs, a Groovy script (\core/config/generateConfigDocs.groovy\) to generate configuration documentation from Spring metadata, and \.gitignore\ files for the \codegen-bytebuddy\ and \mmtest\ subdirectories. These additions establish the tooling and structure for maintaining core configuration and design documentation.

core · high confidence

Adds documentation site styling and search assets

The documentation site now includes a local copy of the DocSearch CSS for the search interface, a font-face stylesheet for Google Fonts (Open Sans, Raleway, Montserrat) that references locally cached font files from the gstatic CDN, and a custom site stylesheet defining typography, syntax highlighting colors, and layout rules for the Antora-generated documentation.

antora/supplemental-ui/css · high confidence

Adds layout-v1 XSD schemas to supplemental UI

The Antora supplemental UI now includes the XML Schema Definition (XSD) files for the layout-v1 specification, covering component definitions, Bootstrap 3 grid and menu bar structures, and link metadata. These files are now available in the documentation source, enabling users to validate their layout XML against the schema directly within the Antora documentation site.

antora/supplemental-ui/applib/layout-v1 · high confidence

Adds local SecMan authentication for the HTMX webcomponents viewer

This change introduces a new module that provides local sign-in and sign-out capabilities for the HTMX-based webcomponents viewer. It adds a dedicated login page served via a servlet filter, along with success and failure handlers that manage session migration and safe-redirect logic to prevent open-redirect vulnerabilities. The module integrates with the existing SecMan security infrastructure, enforcing CSRF protection on login, logout, and GraphQL endpoints, and includes configuration properties to customize the login/logout paths and cookie cleanup behavior.

viewers/webcomponents/htmx-security-secman · high confidence

Adds local Vue SecMan authentication and login UI

Introduces a new Spring module that provides a self-contained authentication flow for the Vue webcomponents viewer. It adds a configurable login page (served at /vue/login), a logout endpoint, and an authentication context endpoint (/vue/authentication) that returns the current user's username and CSRF token as JSON for the Vue frontend. The implementation includes security filters to protect the viewer base path and GraphQL endpoint, enforces CSRF protection on login/logout/GraphQL, validates safe redirect destinations to prevent open redirects, and requires the explicit enabling of Spring CSRF filters via the causeway.security.spring.allow-csrf-filters configuration property.

viewers/webcomponents/vue-security-secman · high confidence

A new partial template for the header content menubar has been introduced, which renders a 'Home' link in the navigation bar. Currently, this link points to a placeholder URL ('\#'), serving as scaffolding for the documentation site's header structure.

antora/supplemental-ui/partials · high confidence

Adds retired reference artifacts and build scripts

The retired directory now includes a cribsheet documenting build workflows, a collection of shell scripts for building, testing, and managing the project (including GitHub PR merging and branch cleanup), and Java source files for Log4j2 plugins (DuplicateMessageFilter and TruncatingMessageFactory) intended as reference implementations.

retired · high confidence

Adds retry action for command log entries with explicit publishing controls

A new 'Retry' action is now available for command log entries, allowing users to reset a command's state (clearing results, exceptions, and timestamps) and mark it as PENDING for re-execution. This action is explicitly configured with commandPublishing and executionPublishing set to DISABLED to prevent redundant event emissions during the retry process.

causeway-extensions-commandreplay-primary · high confidence

Adds sample domain objects for web component verification

The sample HTML viewer now includes \SampleObject\ and \SampleRelatedObject\ domain entities to provide deterministic data for verifying web component rendering. These objects expose various field types (strings, dates, booleans, enums) and relationships, allowing users to test how the framework-neutral web components handle different data shapes and interactions within the sample application.

causeway-viewer-webcomponents-sample-html · high confidence

Adds simple in-memory authentication module with password encryption

Introduces a new 'Simple' authentication module for Apache Causeway, providing an in-memory user and role management system suitable for development or testing. The module includes a SimpleRealm for storing users and roles, and a SimpleAuthenticator that validates credentials using Spring's PasswordEncoder, ensuring passwords are stored and compared in encrypted form rather than plain text.

causeway-security-simple · high confidence

Adds test-support services for configuration, interactions, method removal, and titles

The mmtestsupport module now provides four new classes to simplify JUnit testing: ConfigurationTester allows testing with specific Causeway configuration properties; InteractionService\_forTesting offers a side-effect-free interaction service for tracking interaction layers; MethodRemover\_forTesting records method removal calls for verification; and TitleServiceForTesting provides simplified title and icon generation for domain objects.

causeway-core-mmtestsupport · high confidence

Automatic creation of application users on successful OAuth2 login

The Delegated Spring OAuth2 extension now includes an {@code ApplicationUserAutoCreationService} that automatically provisions a new {@code ApplicationUser} when a user successfully authenticates via OAuth2 (specifically when the principal is an {@code OidcUser}). The creation behavior is governed by the {@code autoCreatePolicy} configuration setting, allowing users to be created as either locked or unlocked, and optionally assigning initial roles based on the configured {@code initialRoleNames}. This service listens for authentication success events and ensures the user is only created if they do not already exist.

extensions/security/secman/delegated-springoauth2 · high confidence

Command Log extension introduces command replay and background execution capabilities

The Command Log extension now provides a comprehensive framework for recording, managing, and replaying application commands. Users can view and search command history via the new Activity menu, with contributions showing recent commands for specific users or objects. The extension introduces a Command Replay Manager that allows administrators to export, import, and replay command sequences to secondary systems for regression testing or state synchronization, including support for excluding or retrying specific commands. Additionally, a new BackgroundService and RunBackgroundCommandsJob enable the execution of commands asynchronously, with controls to pause, resume, and monitor background command execution.

extensions/core/commandlog/applib · high confidence

Command Replay Manager with movement and exclusion controls

The Command Log extension introduces a new CommandManager ViewModel that organizes replayable commands into distinct collections: eligible foreground commands, excluded commands, and pending/failed or recorded/replayed commands. Users can now move selected commands to a new position in the sequence (adjusting their timestamps to maintain order) and restore previously excluded commands back to a replayable state. The ReplayableCommand view model displays execution status via FontAwesome icons and exposes participant details (target, parameter, result) for inspection. Additionally, the FakeScheduler used in integration testing now invokes background command listeners after execution.

causeway-extensions-commandlog-applib · high confidence

Command Replay primary-side infrastructure and UI services

This change introduces the primary-side components for the Command Replay extension, activated via the 'commandreplay-primary' Spring profile. It adds a Spring module configuration that wires up the primary services, a configuration class to read the secondary Wicket base URL, and a mixin action allowing users to open an entity on the secondary instance. It also provides a domain service for retrieving command logs by interaction ID, a SPI processor to capture command execution results and timings, and a UI service (exposed as 'Activity') that enables searching and downloading command logs as XML.

incubator/extensions/core/commandreplay/primary · high confidence

Command replay on secondary instances via Quartz scheduling

The command-replay extension now supports running on secondary instances to automatically replicate and replay commands from a primary system. This is achieved through a new Spring module (activated by the 'commandreplay-secondary' profile) that configures a Quartz job to periodically fetch command logs and execute them on the secondary. The system includes services to analyze replay results for discrepancies in exceptions or outcomes, and provides UI actions to manually upload commands or exclude specific entries from the replay queue.

incubator/extensions/core/commandreplay/secondary · high confidence

Demo app adds local replay control actions

The demo application now includes a dedicated controller (DemoReplayController) that exposes resume and pause actions for command replay within the web UI. This implementation allows users to manually control the state of the command replay process directly from the demo interface, supplementing the core replay infrastructure.

incubator/examples/demo/web · high confidence

Documentation for Apache Causeway Starter Apps

Added new Asciidoctor documentation pages for the HelloWorld and SimpleApp starter applications. The new content includes navigation structures, an overview of the starter apps, and detailed guides on prerequisites, downloading, and running the applications via Maven or Docker. It also covers usage instructions for the Wicket viewer and Swagger REST API, along with code examples for domain objects and services.

starters/adoc/modules/starters · high confidence

Excel exporter supports individual cell coloring and uses streaming for large files

The Excel exporter in the tabular-excel extension now allows users to apply custom background colors to individual cells or entire rows via the new \cellStyleFunction\ and \rowStyleFunction\ options in \ExcelFileWriter.Options\. It also switches the underlying Apache POI implementation from \XSSFWorkbook\ to \SXSSFWorkbook\, enabling streaming writes that handle large datasets without exhausting memory, while maintaining automatic column and row sizing.

causeway-extensions-tabular-excel · high confidence

Excel fixture extension adds demo app for bulk import/export and pivot analysis

The Excel fixture extension now includes a demo application that demonstrates bulk updating of To-Do items via Excel spreadsheets, including importing and exporting data through a dedicated manager service, as well as generating pivot tables aggregated by category and subcategory. It also provides fixture scripts and row handlers to populate the demo data from Excel resources, enabling users to test and understand the Excel integration capabilities within the framework.

extensions/core/excel/fixture · high confidence

Execution Outbox extension adds persistent execution logging and REST API

The Execution Outbox extension now provides a new \ExecutionOutboxEntry\ domain model and repository to persist records of action invocations and property edits, enabling users to track execution history and audit trails. This change introduces a Spring configuration module that wires the entry, menu, and subscriber components, and adds an \OutboxRestApi\ with an \OutboxEvents\ wrapper to expose pending execution logs via a REST endpoint, including content mapping to serialize the entries as \InteractionsDto\ for external consumers.

extensions/core/executionoutbox/applib · high confidence

ExecutionOutboxEntry JPA persistence model introduced

The JPA persistence layer for the Execution Outbox now uses a concrete entity class (ExecutionOutboxEntry) and a composite primary key (ExecutionOutboxEntryPK) to store execution metadata. This change introduces the database schema mapping for interaction IDs, sequences, execution types, timestamps, and target bookmarks, enabling the outbox to persist execution state for auditing and replay.

causeway-extensions-executionoutbox-persistence-jpa · high confidence

Foundational command replay controls: recording suppression, advisor policies, and bookmark remapping

This change introduces the core infrastructure required for reliable command replay in Causeway 4. It adds an opt-in \recording-support\ configuration (disabled by default) that allows marking specific domain objects or view models to suppress command logging, and provides application-wide pause/resume events to temporarily suspend persistence (e.g., during initial fixture installation). It also defines a configurable interaction-advisor policy (\CHECK\, \CHECK\_BUT\_IGNORE\, \NO\_CHECK\) for command DTO execution, ensuring replayed actions and properties can be validated or bypassed as needed. Finally, it implements a replay-mapping SPI and an in-memory listener that remaps recorded target and reference-parameter bookmarks before execution, allowing replayed commands to be redirected to new objects while preserving the original audit data.

openspec · high confidence

FullCalendar Wicket UI viewer implementation

The Wicket UI layer for the FullCalendar extension is introduced, providing concrete Wicket components that render collections of domain objects as interactive calendar views. This includes the Spring module configuration, abstract base panels for calendar rendering, and specific factories and event providers for both Calendarable and CalendarEventable domain types, along with the necessary HTML templates and CSS styling to display the calendar in the Wicket viewer.

extensions/vw/fullcalendar/wicket/ui · high confidence

GraphQL viewer documentation and analysis artifacts

Adds comprehensive documentation for the GraphQL viewer, including guides on API variants (Simple vs Rich schemas), i18n handling via AsciiIdentifierService, and rich schema capabilities like application entry points and collection windowing. Includes a detailed reference application coverage analysis with a coverage matrix, probe operations, and summary to identify correctness gaps in object interaction, value semantics, and resource links.

viewers/graphql/adoc/modules/ROOT · high confidence

GraphQL viewer introduces extensible marshalling and authentication SPIs

The GraphQL application library now exposes new service provider interfaces (SPIs) that allow users to customize how data is converted and how user identity is determined. The new ScalarMarshaller interface enables custom marshalling of Java scalar types to and from GraphQL scalar types, supporting a chain-of-responsibility pattern where implementations can opt into reversible input coercion. Additionally, the UserMementoProvider interface allows applications to define how the executing user's identity is extracted from the GraphQL execution context, replacing the previous static fallback with a pluggable mechanism.

viewers/graphql/applib · high confidence

GraphQL viewer now supports configurable schema styles (Simple, Rich, and combined)

The GraphQL viewer now allows users to choose between 'Simple', 'Rich', or combined schema styles via the \viewer.graphql.schemaStyle\ configuration property. This change introduces new top-level query and mutation types (\SimpleTopLevelQuery\, \RichTopLevelQuery\, etc.) and a custom execution strategy that ensures GraphQL field resolution occurs within the correct Causeway interaction context. The viewer also enforces that full metamodel introspection is enabled, as required for generating the GraphQL schema dynamically.

viewers/graphql/viewer · high confidence

HTMX Pet Clinic sample application with declarative web component layouts

A new sample application demonstrating the HTMX web component viewer is added, featuring both a permissive mode and a secured mode with local SecMan authentication. The sample includes a custom HTML shell, declarative layout files for pages (Home, Pet, PetOwner, Visit), collections, and previews, along with Playwright acceptance tests to validate the UI behavior.

viewers/webcomponents/sample-htmx-petclinic · high confidence

Initial JDBC persistence module stub

Adds a new stub module for JDBC-based persistence, introducing the JdbcEntityFacet to handle entity lifecycle operations (fetch, persist, refresh, delete) via Spring Data JDBC. The module registers the JdbcEntityFacetFactory to detect entities annotated with @Persistent and wires the necessary Spring Data relational components for metadata mapping and data access.

persistence/jdbc · high confidence

Initial prototype for tabular PDF export

The tabular PDF export extension now includes a working proof-of-concept that renders tabular data into PDF documents. This implementation introduces a new PDF generation engine built on Apache PDFBox, replacing previous approaches. It supports exporting tabular sheets with headers and data rows, handling various data types including strings, dates, numbers, and images. The system includes font management utilities that load FreeSans fonts and handle character encoding, with fallback mechanisms for unsupported characters. The export functionality is accessible through the PdfFileWriter class, which coordinates the creation of PDF documents from tabular models.

causeway-extensions-tabular-pdf · high confidence

Interactive D3.js object graph diagrams in generated documentation

The Asciidoc builder now includes a D3.js-based renderer for ObjectGraph diagrams, replacing or supplementing previous static representations. This change introduces an interactive, force-directed graph visualization in the generated documentation, allowing users to drag and drop nodes, toggle node highlights to emphasize incoming edges, and view detailed tooltips containing field information. The implementation leverages D3.js v4 and includes specific CSS and JavaScript assets to support these interactive features.

causeway-valuetypes-asciidoc-builder · high confidence

Introduce generic Vue viewer for application routing and shell integration

This change adds a new Vue-based viewer implementation for the Causeway web components, providing the core routing infrastructure and UI components. It introduces Vue components for the application home page, generic object pages, and object route handling, along with a plugin system to integrate with the Vue router and application shell. The viewer includes boundary validation to ensure the correct DOM structure, policy hooks for customizing navigation and action handling, and support for local resource navigation with security checks. It also handles logout actions by suppressing them in menus and placing secured sign-out in the tertiary menu, while consolidating utility menu and action results.

viewers/webcomponents/vue · high confidence

Introduces Markdown value type with JAXB support

Adds a new Markdown value type to the Causeway application library, allowing users to store and manage Markdown content. The implementation includes a JAXB adapter to enable serialization support for view models, ensuring the Markdown value can be persisted and transmitted correctly within the framework.

causeway-valuetypes-markdown-applib · high confidence

Introduces Querydsl support for persistence queries

Adds a new \persistence/querydsl/applib\ module that integrates Querydsl into the framework. This includes a \QueryDslRepository\ base class for type-safe entity querying, \QueryDslSupport\ and \DetachedQueryFactory\ interfaces for building and executing queries, and an \AutoCompleteGeneratedQueryService\ to support declarative autocomplete features defined via \@DomainObject\ and \@Property\ annotations. The module also provides utility classes for wildcard-to-regex conversion and case sensitivity handling, along with a \PredicatePrettifier\ in the testsupport module for debugging query predicates.

persistence/querydsl/applib · high confidence

Introduces SPI for PDF.js viewer configuration

Adds the PdfJsViewerAdvisor service interface, which allows implementations to provide specific rendering advice (such as page number, scale, and height) for PDF objects viewed in the application. This SPI enables customization of how PDF blobs are rendered by users, with a default implementation that currently returns null advice.

causeway-extensions-pdfjs-applib · high confidence

Introduces Server-Sent Events (SSE) support in the Wicket viewer

This change adds the Wicket-specific implementation for the Server-Sent Events extension, enabling real-time, server-push updates to the UI. It introduces a new Spring module configuration that wires together the SSE service, a dedicated servlet for handling asynchronous event streams, and Wicket markup components that inject client-side JavaScript to listen for these events. Users can now utilize SSE capabilities within Wicket-based applications, allowing views to react to backend changes without polling.

extensions/vw/sse/wicket · high confidence

Introduces Vega chart value type support

Adds the \VegaValueSemantics\ component to the metamodel, enabling the use of Vega and Vega-Lite chart specifications as value types within applications. This change provides the underlying semantics for parsing, rendering, and decomposing Vega JSON data, allowing users to store and display interactive charts directly in their domain models.

valuetypes/vega/metamodel · high confidence

Introduces Vega value type for interactive visualizations

Adds a new immutable Vega value type to the Causeway application library, allowing domain models to hold JSON payloads for interactive visualizations (Vega and Vega-Lite). This change includes the core value class, a builder interface, stringification utilities, and a JAXB adapter to support serialization in view models, alongside the necessary Java module descriptor and Spring configuration stub.

valuetypes/vega/applib · high confidence

Introduces Wicket UI for PDF.js viewer

Adds the Wicket-based user interface components for the PDF.js viewer extension, including the main Spring module configuration, the \PdfJsViewerPanel\ component factory, and the associated HTML, CSS, and JavaScript resources. This enables the rendering of PDF blobs within the Causeway Wicket viewer with interactive features such as page navigation, zoom, and printing.

extensions/vw/pdfjs/wicket/ui · high confidence

Introduces declarative web component foundation for actions, collections, and application menus

This change adds the core web component foundation for the Causeway viewer, introducing a suite of new declarative elements and their supporting logic. Users can now define application menus, navigable breadcrumbs, and interactive action buttons using custom elements (e.g., \\<cw-action\>\, \\<cw-collection\>\, \\<cw-breadcrumbs\>\). The foundation includes a robust action dispatch system that supports nested queries, root mutations, and legacy mutations, along with declarative result presentation styles (inline, dialog, sidebar). Collection handling is enhanced with declarative column definitions, sorting, filtering, and paging capabilities, backed by a new grid projection system. Additionally, the foundation provides the infrastructure for rich GraphQL application entry reads, including menu bar descriptors and home object resolution.

viewers/webcomponents/foundation · high confidence

Introduces extensible HTMX web component viewer with application-authored shell support

The HTMX viewer now allows applications to provide their own HTML shell structure via the new HtmxAuthenticationShell interface and HtmxShellDefinition, enabling custom authentication chrome and layout while the framework handles declarative template binding, route context management, and validation of required web component slots (such as cw-graphql-client and cw-menubars).

causeway-viewer-webcomponents-htmx · high confidence

Introduces generic HTMX web component viewer

Adds a new HTMX-based viewer module that allows applications to define custom HTML pages, collection presentations, previews, and application shells via classpath resources. The module registers Spring beans to load and validate these HTML fragments, supporting both cached and development-time reload modes, and renders them using a declarative template system with configurable authentication and routing.

viewers/webcomponents/htmx · high confidence

Introduces metamodel support for Server-Sent Events (SSE) annotations

The metamodel extension now recognizes the @ServerSentEvents annotation on methods. A new SseAnnotationFacetFactory processes these annotations to create an SseObserveFacet, which identifies the associated SseSource event stream type and automatically derives the corresponding SSE endpoint path (e.g., /sse?eventStream=...). This enables the application to expose method results as real-time server-sent event streams.

extensions/vw/sse/metamodel · high confidence

Introduces modular GraphQL model with simple and rich schema strategies

The GraphQL viewer is now structured as a dedicated module (org.apache.causeway.incubator.viewer.graphql.model) that exposes a new, pluggable schema architecture. This change introduces a SchemaStrategy interface with two distinct implementations—Simple and Rich—allowing the GraphQL API surface to be tailored to different needs. The model layer now handles the construction of GraphQL types, data fetchers, and input/output semantics for domain objects, services, actions, and properties, while also supporting hyphenated namespaces in logical type names.

viewers/graphql/model · high confidence

Introduces rich GraphQL model semantics for actions, collections, and application entry points

The GraphQL viewer now exposes a richer, more structured API by adding new model classes that provide detailed metadata and interaction capabilities. Users can now access application entry points (menu bars, home page, and diagnostics) via the new \application\ query, and action invocations are exposed with granular fields for target, arguments, and results, differentiated by action semantics (safe, idempotent, non-idempotent). Collections and actions now include \hidden\, \disabled\, and \validity\ metadata, allowing clients to understand UI constraints. Additionally, autocomplete functionality is enhanced with a bounded \autoCompleteWindow\ that returns paginated results with offset and size details, and blob/clob properties are exposed via dedicated resource paths for efficient data retrieval.

causeway-viewer-graphql-model · high confidence

Introduction of the commons module with core utility APIs

The commons module has been introduced, providing a new set of core utility APIs for the platform. This includes the \Can\<T\>\ immutable collection type for handling zero, one, or multiple elements, binding interfaces (\Observable\, \Writable\) for state management, and functional interfaces like \IndexedConsumer\ and \ThrowingRunnable\. The module also exposes internal utilities for assertions, byte manipulation, and constants, along with a Java module descriptor (\module-info.java\) that defines the public API surface and dependencies on libraries such as Jackson, JAXB, and Micrometer.

commons · high confidence

JPA persistence implementation for Execution Outbox

This change introduces the JPA-based persistence layer for the Execution Outbox extension, providing the concrete repository, entity mappings, and Spring Boot configuration required to store outbox entries using JPA (specifically EclipseLink). It includes the module configuration, the JPA repository implementation, and integration tests to verify the functionality.

extensions/core/executionoutbox/persistence-jpa · high confidence

JPA persistence implementation for the Execution Log extension

The Execution Log extension now includes a JPA-based persistence module, providing a concrete repository implementation for storing execution log entries. This change introduces the necessary Spring Boot configuration, entity definitions, and a JPA repository to persist log data, along with integration tests and a test-specific persistence configuration (migrated to Jakarta EE 3.0 schema) to verify the functionality.

extensions/core/executionlog/persistence-jpa · high confidence

JPA persistence layer for the Command Log extension

This change introduces the JPA-based persistence implementation for the Command Log extension, providing the database storage for command execution logs and replay-result mappings. It registers the \CommandLogEntry\ and \CommandReplayResultMapping\ entities, along with their respective Spring Data repositories, within the \CausewayModuleExtCommandLogPersistenceJpa\ configuration. The module also includes a teardown fixture for test cleanup and an ORM template for schema generation. Additionally, it adds integration tests to verify the persistence of command logs, the behavior of the command background gate, and the workflow mutations of the unified command manager.

extensions/core/commandlog/persistence-jpa · high confidence

JPA persistence support for Session Log extension

The Session Log extension now includes a JPA-based persistence module, enabling session activity to be stored in a relational database via EclipseLink. This change introduces the \SessionLogEntry\ entity and its repository, along with a Spring Boot auto-configuration module (\CausewayModuleExtSessionLogPersistenceJpa\) that registers the necessary beans and scans for entities. It also provides a teardown fixture script for manual cleanup during testing and includes integration tests to verify the persistence layer works correctly with the application's security and runtime services.

extensions/security/sessionlog/persistence-jpa · high confidence

JPA regression test base module split

The regression test base module has been split to provide a dedicated JPA test domain, introducing JPA-specific entities (JpaBook, JpaInventory, JpaProduct), view models (JpaInventoryJaxbVm, JpaBookView), and Spring Boot configurations (Configuration\_usingJpa, Configuration\_usingSpringDataJpa) to support testing against JPA persistence stacks.

regressiontests/base-jpa · high confidence

Markdown value type metamodel implementation

The metamodel layer for the Markdown value type has been introduced, providing the semantic wiring for the Markdown value. This includes a Spring configuration module that imports the MarkdownValueSemantics component, which implements the Parser and Renderer interfaces to handle the conversion, decomposition, and HTML rendering of Markdown values within the application.

valuetypes/markdown/metamodel · high confidence

Markdown value type support added to Causeway

The valuetypes/markdown/applib module has been introduced, providing a new capability to convert Markdown content to HTML within the application. This includes a new module definition (org.apache.causeway.valuetypes.markdown.applib) that exposes packages for value handling and JAXB, and relies on the Flexmark library (including GFM strikethrough and table extensions) for rendering. A new configuration class, CausewayModuleValMarkdownApplib, registers the module namespace, and a Converter utility class enables the actual Markdown-to-HTML transformation, supporting features like tables and strikethrough syntax out of the box.

valuetypes/markdown/applib · high confidence

New 'Beyond the Basics' user guide section

Adds a new 'Beyond the Basics' (btb) module to the Apache Causeway user guide, providing documentation for advanced topics. This includes guides on headless access (interacting with the runtime outside standard viewers), customizing the programming model, internationalization (i18n), logging configuration (including the DuplicateMessageFilter and TruncatingMessageFactory), and troubleshooting visibility and usability issues. The section also offers practical hints and tips, such as implementing 'Are you sure?' confirmations, custom CSS, handling void/null results, spellchecking, persisting object titles, overriding default service implementations, and managing subclass properties in tables.

antora/components/userguide/modules/btb · high confidence

New Antora block macros for Jira issues and placeholder text

Added two new Antora extension files in the lib directory: jira-issue.js and lorem.js. The jira-issue.js file registers a block macro that converts Jira issue keys into clickable links to the Apache Jira instance. The lorem.js file registers a block macro that generates placeholder 'lorem ipsum' text for documentation purposes, allowing authors to insert dummy content during drafting.

antora/lib · high confidence

New Apache Causeway Petclinic sample domain and UI layout

This location introduces the complete domain model and presentation layer for the Petclinic sample application. It adds seed data configuration to populate pet owners, pets, and visits, alongside domain services for filtering and repository access. The UI is defined through layout XML files that structure the home page, pet owner details, and pet records, and configure primary menus for managing owners and scheduling visits, as well as a tertiary account menu.

viewers/webcomponents/sample-petclinic-domain · high confidence

New AsciiDoc styling themes added to Antora

Two new CSS style sheets, \asciidoc-classic\ and \boot-flatly\, have been added to the Antora AsciiDoc styles directory. The \asciidoc-classic\ theme provides a traditional look with Georgia serif fonts for body text and specific styling for headings, lists, and code blocks. The \boot-flatly\ theme applies the Flatly design system (via Bootswatch), featuring the Lato font, a clean white background, and distinct styling for blockquotes, tables, and links, giving documentation a modern, Bootstrap-inspired appearance.

antora/.asciidoctor-styles · high confidence

New AsciiDoc value type with automatic HTML rendering and PlantUML support

This change introduces the \AsciiDoc\ value type within the \causeway-valuetypes-asciidoc-applib\ module, allowing domain models to store AsciiDoc markup that is automatically converted to HTML for display. The implementation registers a Spring configuration module that initializes an Asciidoctor converter, enabling syntax highlighting via Prism. Additionally, if the \kroki\ backend URL is configured, the converter registers extensions to support PlantUML diagrams within AsciiDoc blocks, converting them into open blocks processed by the Kroki service. A JAXB adapter is also provided to ensure the \AsciiDoc\ value type serializes correctly in XML contexts.

causeway-valuetypes-asciidoc-applib · high confidence

New CI scripts for site generation and build orchestration

The CI pipeline now uses a new set of shell scripts in scripts/ci/ to orchestrate builds and documentation. The main entry point, build-site.sh, delegates to \_build-site.sh, which conditionally runs helper scripts to copy examples, generate configuration documentation from Spring metadata, generate project documentation, fix line endings, and finally run Antora to build the site. Additional scripts handle building artifacts and Docker images, calculating baseline and revision versions, and performing a dry-run build. A new Groovy script, checkmissinglicenses.groovy, has been added to identify dependencies with missing license information by comparing Maven license reports against the supplemental-models.xml file.

scripts · high confidence

New CORS extension module for Apache Causeway

A new extension module has been added to handle Cross-Origin Resource Sharing (CORS) for RESTful endpoints. The implementation registers a Spring Filter that applies CORS policies to the REST base path (defaulting to /restful/\*), allowing administrators to configure allowed origins, methods, headers, and credentials via the application configuration. A corresponding test verifies that the filter is correctly mapped to the expected URL pattern using default settings.

extensions/vro/cors/impl · high confidence

New CalendarEvent value type for the FullCalendar extension

The FullCalendar extension now provides a new \CalendarEvent\ value type, allowing users to model calendar events with a title, calendar name, optional notes, and a timestamp. This value type includes built-in semantics for serialization (via JAXB and value decomposition), rendering (custom HTML and title templates), and default value generation, enabling richer interaction with calendar data within Causeway applications.

causeway-extensions-fullcalendar-applib · high confidence

New DataTableProvider for tabular data integration

A new abstract DataTableProvider class has been added to the tabular application library, providing a centralized way to generate DataTable instances for domain object types. This provider automatically configures table columns by excluding mixins and including only properties enabled for snapshots, and offers methods to stream data tables and entity specifications for all registered entity types.

extensions/vw/tabular/applib · high confidence

New Excel export capability for tabular data

The tabular data integration now supports exporting to Excel (.xlsx) format. This new feature allows users to download tabular views as Excel files, with support for various data types including strings, numbers, dates, and images (with automatic resizing). The export is implemented via a new TabularExcelExporter component that integrates with the existing tabular model.

extensions/vw/tabular/excel · high confidence

New Execution Log extension for tracking command and property executions

The Execution Log extension introduces a new \ExecutionLogEntry\ domain object and repository to persist and query command and property executions. Users can now view recent executions via the \Activity\ menu, filter by date range, or inspect executions linked to specific objects, users, or interactions through contributed collections and actions.

extensions/core/executionlog/applib · high confidence

New GitHub Layout Loader extension

Adds a new extension that enables dynamic loading of domain model layout resources directly from a GitHub repository. Users can configure a GitHub repository and API key via the \causeway.extensions.layoutLoaders.github\ configuration properties. The extension provides a tertiary menu with actions to enable or disable dynamic layout loading at runtime, allowing the application to fetch and apply layout definitions (e.g., \.layout.xml\ files) from the specified repo on demand.

extensions/core/layoutloaders/github · high confidence

New JPA metamodel module for annotation-driven persistence metadata

A new \persistence/jpa/metamodel\ module has been introduced to handle JPA-specific metadata derivation. It registers facet factories that interpret JPA annotations—such as \@Table\, \@Column\, and \@Transient\—to configure domain object properties. This allows the application to automatically derive table names, column constraints (like mandatory status and max length), and transient behavior directly from JPA annotations, replacing or supplementing previous mechanisms.

persistence/jpa/metamodel · high confidence

New JPA persistence module for the SecMan security extension

The SecMan security extension now includes a new JPA persistence module that stores application permissions, roles, tenancies, and users in a dedicated database schema named 'causewayExtSecman'. This module provides the JPA entity mappings, Spring Data repositories, and a Spring Boot auto-configuration module to enable persistent storage of security data, along with integration tests to verify the consistency of role assignments and tenancy hierarchies.

extensions/security/secman/persistence-jpa · high confidence

New JPA-based regression test domain model and services

The JPA regression test base module now includes a comprehensive set of new domain entities and services to support testing. This includes entity classes such as JpaBook, JpaProduct, JpaInventory, and JpaProductComment, along with supporting entities like JpaEntityGeneratedLongId and JpaEntityNonGeneratedStringId. A new domain service, JpaInventoryResource, provides actions for managing these entities, while JpaRestEndpointService facilitates RESTful interactions using Spring's RestClient. Additionally, LifecycleEventSubscriberJpaForTesting captures JPA lifecycle events for testing purposes, and an Employee entity is added for Spring Data integration tests.

causeway-regressiontests-base-jpa · high confidence

New Keycloak security module for OAuth2/OIDC authentication

A new \security/keycloak\ module has been added to provide Keycloak-based authentication. This module registers a Spring Security \SecurityFilterChain\ that enables OAuth2/OIDC login, configures a JWT decoder for token validation, and integrates a custom \KeycloakOauth2UserService\ for user info retrieval. It also includes a dedicated logout handler to propagate logout events to Keycloak and manages session creation policies, allowing users to authenticate against a Keycloak realm.

security/keycloak · high confidence

New PDF tabular export extension

A new extension has been added to enable exporting tabular data as PDF documents. This feature introduces a \TabularPdfExporter\ component that integrates with the existing tabular export framework, allowing users to download table views as PDF files. The implementation uses Apache PDFbox for rendering, supporting features like styled headers, alternating row colors, and image cells within the exported tables.

extensions/vw/tabular/pdf · high confidence

New Pet Clinic domain model for the WebComponents viewer sample

This change introduces the core domain entities and services for a sample Pet Clinic application within the \causeway-viewer-webcomponents-sample-petclinic-domain\ bounded context. It adds JPA entities for \Pet\, \PetOwner\, and \Visit\, along with domain services (\PetOwners\, \Visits\) that provide actions for creating owners, searching by name, listing all owners, and viewing upcoming visits. The domain also includes a \ViewerFallback\ entity to demonstrate local resource opening and logout capabilities, and a \PetClinicPdfDocument\ reference for generating owner agreement documents.

causeway-viewer-webcomponents-sample-petclinic-domain · high confidence

New REST client for the Execution Outbox extension

This change introduces a new REST client library for the Execution Outbox extension, allowing applications to programmatically interact with outbox entries via HTTP. It provides an \OutboxClient\ API that supports retrieving pending interactions, deleting single entries, and deleting multiple entries, with configurable URIs for these operations. The module includes a Spring configuration class to wire the client and adds integration tests to verify its behavior against a running server.

extensions/core/executionoutbox/restclient · high confidence

New RestfulObjects client with OAuth2 Azure authentication support

The RestfulObjects viewer now includes a new client module that provides a modern REST client implementation. This client supports both Basic and OAuth2 Azure authentication modes, allowing users to configure credentials via the RestfulClientConfig. It also introduces configurable request/response debug logging through ClientConversationFilter and uses Jackson for JSON parsing.

viewers/restfulobjects/client · high confidence

New Spring OAuth2 extension for JWT and OAuth2 user authentication

The \spring-oauth2\ extension is introduced to support authentication via Spring Security's OAuth2 client. It provides configuration beans that import the core Spring security module and register authentication converters for both JWT tokens and OAuth2 user principals. The JWT converter extracts the user name from the 'appid' claim or subject, while the OAuth2 user converter maps attributes like 'login', 'avatar\_url', and 'name' to the user profile. Additionally, a RESTful authentication strategy is added to enable stateless JWT-based authentication for Restful Objects clients by configuring the \isis.viewer.restfulobjects.authentication.strategy-class-name\ property.

extensions/security/spring-oauth2 · high confidence

New Wicket integration layer for FullCalendar

This change introduces the Wicket integration module for the FullCalendar extension, providing the server-side components and configuration required to embed and interact with the calendar in Apache Wicket applications. It adds the \CausewayModuleExtFullcalendarWicketIntegration\ Spring module, the core \FullCalendar\ and \AbstractFullCalendar\ Wicket components, and a suite of callback classes (such as \EventClickedCallback\ and \DateRangeSelectedCallback\) to handle client-side events via AJAX. The diff also includes supporting configuration classes like \CalendarConfig\ and \EventSource\, as well as resource references for the FullCalendar JavaScript assets.

extensions/vw/fullcalendar/wicket/integration · high confidence

New abstract base class for GraphQL integration tests

The \causeway-viewer-graphql-testsupport\ module now provides \CausewayViewerGraphqlIntegTestAbstract\, a new base class designed to simplify integration testing for GraphQL viewers. This class automatically configures a Spring Boot test context with security bypassed and an in-memory H2 database, allowing developers to write tests by placing GraphQL query files with a \.gql\ suffix in their test resources. It leverages JUnit 5 dynamic tests and approval testing to validate responses, reducing the boilerplate required to set up HTTP clients and test fixtures for GraphQL endpoints.

causeway-viewer-graphql-testsupport · high confidence

New abstract test utility for exporting GraphQL schemas

Introduces PrintSchemaIntegTestAbstract, an abstract base class for integration tests that automatically generates and writes the current GraphQL schema to src/test/resources/schema.gql. This enables IDEs to provide code-completion and intellisense for GraphQL queries used in tests, and allows overriding the API variant via Spring's DynamicPropertySource.

viewers/graphql/testsupport · high confidence

New authentication factories and client conversation logging in the RestfulObjects client

The RestfulObjects client now includes dedicated authorization header factories for Basic and Azure OAuth2 authentication modes, along with supporting credential records (BasicCreds, Oauth2Creds) and a new ClientConversationLogger that logs HTTP requests and responses while obscuring sensitive authorization headers.

causeway-viewer-restfulobjects-client · high confidence

New core webapp module with health, configuration, and session management

The core webapp module has been introduced, providing the foundational Spring Boot integration for the application. This includes a health indicator that aggregates results from registered health check services, a configuration view service that exposes application settings and environment details, and a key-value store implementation backed by the HTTP session. Additionally, the module defines a WebModule abstraction for programmatic servlet context initialization, routing filters for documentation redirection, and session-scoped message broker support.

core/webapp · high confidence

New core/interaction module with interaction scope and message broker

This change introduces the new \core/interaction\ module, which provides the infrastructure for managing interaction scopes and cross-boundary messaging. It registers a custom \InteractionScope\ in the Spring container via \InteractionScopeBeanFactoryPostProcessor\, enabling beans to be scoped to the lifecycle of a user interaction. Additionally, it includes \MessageBrokerImpl\, a thread-safe, serializable component that allows messages, warnings, and application errors to be queued and drained across interaction boundaries.

core/interaction · high confidence

Added \VegaDonutDiagram\ and \VegaNodeLinkDiagram\ builder classes in the \causeway-valuetypes-vega-applib\ module. These classes provide a fluent API for constructing Vega and Vega-Lite JSON specifications for donut charts and hierarchical node-link diagrams, respectively, allowing users to programmatically generate these specific diagram types.

causeway-valuetypes-vega-applib · high confidence

New event classes for action argument validation and collection interactions

The \causeway-applib\ module introduces several new event classes to provide finer-grained hooks during object interaction. \ActionArgumentUsabilityEvent\ and \ActionArgumentVisibilityEvent\ allow applications to determine why specific action parameters are disabled or hidden, including the reason message. \ActionArgumentEvent\ and \PropertyModifyEvent\ expose validation checks for individual action arguments and property values, providing the proposed value and position. Additionally, \CollectionMethodEvent\ captures interactions with collection objects themselves, exposing the domain object owner, method name, arguments, and return value.

causeway-applib · high confidence

New filter to log request URLs on exceptions while suppressing client abort noise

A new \CausewayLogOnExceptionFilter\ has been added to the webapp module. This filter intercepts exceptions during request processing to log the URL of the request that caused the error, aiding in debugging. It specifically suppresses logging for \ClientAbortException\ (which occurs when a user navigates away) and ignores static resource requests (\.css\, \.js\, \.woff2\), reducing log noise while preserving visibility into application errors.

core/webapp/src/main/java/org/apache/causeway/core/webapp/modules/logonlog · high confidence

New functional and collection utilities in commons

The commons module introduces several new types to improve type safety and functional programming patterns. A new \Can\<T\>\ type system replaces previous collection wrappers, providing distinct implementations for empty, singleton, and multiple cardinalities, along with a \CanVector\ for fixed-size mutable vectors. Functional programming support is expanded with \Either\, \Railway\ (implementing the Railway Pattern for success/failure chaining), and \Try\ (wrapping operations that may throw exceptions). Additionally, a new \ImmutableEnumSet\ record provides a safe, immutable view over \EnumSet\, and \GraphUtils\ offers basic graph data structures and algorithms.

causeway-commons · high confidence

New interaction-scoped bean lifecycle management

The core interaction module now introduces an \InteractionScope\ that allows beans to be scoped to the lifetime of a single user interaction. This new scope automatically manages bean creation and destruction, ensuring that scoped instances are cleaned up when the top-level interaction closes, which helps prevent memory leaks and ensures state consistency within a user's request context.

causeway-core-interaction · high confidence

New interactive help and entity diagram pages

The docgen help extension now provides a structured, tree-based help interface accessible via a new 'Help' menu item. This interface includes a welcome page that summarizes application home pages and menu actions, and introduces entity relationship diagrams for domain objects. These diagrams are available in two formats: static PlantUML renderings and interactive visualizations powered by D3.js, allowing users to explore their domain model relationships directly within the application.

extensions/core/docgen/help · high confidence

The rendering module introduces four new internal classes to support RESTful Objects rendering logic. LinkFollowSpecs provides a fluent API for matching and following link paths based on path templates and criteria. MutatorSpec defines the contract for applying mutators to object members by checking facet types and HTTP methods. ExceptionPojo and ExceptionDetail are new JAXB-annotated record types that structure exception responses for XML serialization, including HTTP status codes, messages, stack traces, and root cause details.

causeway-viewer-restfulobjects-rendering · high confidence

New internal test support utilities and documentation metadata

This change introduces new internal testing infrastructure within the core/internaltestsupport module. It adds the @DisabledIfRunningWithSurefire annotation, allowing tests to be conditionally skipped when running under the Maven Surefire plugin. It also provides abstract contract test classes (ComparableContractTest\_compareTo and ValueTypeContractTestAbstract) to help verify value-type semantics like equals, hashCode, and compareTo. Additionally, an antora.yml file is added to define documentation metadata for this module.

core/internaltestsupport · high confidence

New persistence commons module with change tracking and deadlock recognition

The persistence/commons module is introduced, providing the core infrastructure for entity change tracking, deadlock recognition, and repository services. It registers the EntityChangeTrackerDefault to monitor and publish entity property changes within transactions, the DeadlockRecognizerDefault to detect deadlocks from Spring's DeadlockLoserDataAccessException and SQL Server messages, and the RepositoryServiceDefault for standard persistence operations. The module also includes metamodel refiners to validate column annotation facets (such as MaxLength, Mandatory, and BigDecimal constraints) and exposes a PreAndPostValueEvaluatorService SPI to control which property changes are published.

persistence/commons · high confidence

New programmatic AsciiDoc builder and writer library

Introduces a new library in the \valuetypes/asciidoc/builder\ module that provides a fluent API for constructing AsciiDoc documents programmatically. The \AsciiDocBuilder\ and \AsciiDocFactory\ classes allow developers to build document models with sections, blocks, tables, and diagrams using Java objects rather than raw text strings. The \AsciiDocWriter\ and \NodeWriter\ components then serialize these models back into AsciiDoc source, supporting various block styles and diagram types. This enables dynamic generation of documentation content within the application.

valuetypes/asciidoc/builder · high confidence

New runtime services and refactored icon handling

This update introduces several new core runtime services, including a PO-based translation writer and menu for prototyping, a default object lifecycle publisher, a scratchpad for interaction-scoped data, and an exception recognizer for Spring DataAccessExceptions. It also re-implements the ObjectIconService to consolidate support for embedded, FontAwesome, and classpath-based icons, and refactors the async proxy mechanism to use TryFuture for better error handling.

causeway-core-runtimeservices · high confidence

New security-bypass module for integration testing

A new 'security-bypass' module has been added to the framework, providing a dedicated Spring configuration module (CausewayModuleSecurityBypass) that registers bypass implementations for both authentication (AuthenticatorBypass) and authorization (AuthorizorBypass). These components are designed for integration testing scenarios, where they allow all authentication requests to be considered valid and all object visibility/usability checks to pass, effectively disabling security enforcement for the duration of the test.

security/bypass · high confidence

New simple in-memory security module

Adds a new 'security/simple' module providing a lightweight, in-memory authentication and authorization implementation. This module introduces a SimpleRealm for managing users and roles, a SimpleAuthenticator for password-based login (using BCrypt), and a SimpleAuthorizor for checking read/change permissions based on role grants. It is designed as a drop-in replacement for development or simple use cases, requiring only the standard Causeway core and Spring Security crypto dependencies.

security/simple · high confidence

New template resource serving and caching infrastructure

The webapp now includes a new \TemplateResourceServlet\ and \TemplateResourceCachingFilter\ within the \templresources\ module. The servlet handles HTML templates by loading them from the file system or classpath, replacing placeholders with runtime values (such as the restful base path), and serving the resulting content. The accompanying filter manages HTTP caching headers (Cache-Control, Expires, Last-Modified) based on a configurable cache time, and marks cached requests via a request attribute to allow other filters to skip unnecessary session handling.

core/webapp/src/main/java/org/apache/causeway/core/webapp/modules/templresources · high confidence

New test-support classes for metamodel and service injection

The core/mmtestsupport module now includes a suite of new classes to facilitate testing: FactoryService\_forTesting, MetaModelContext\_forTesting, ServiceInjector\_forTesting, ServiceRegistry\_forTesting, TranslationService\_forTesting, WrapperFactory\_forTesting, \_InjectorMethodEvaluator, \_ServiceInjectorLegacy, and \_TestDummies. These provide test-specific implementations of core services (factory, service registry, injector, translation, wrapper) and a builder-based MetaModelContext, enabling unit tests to instantiate and inject services into domain objects without a full application context.

core/mmtestsupport · high confidence

New title cache API interfaces for domain objects

The title cache extension now provides a new \applib\ module containing marker interfaces that allow domain objects to opt into title caching. Implementing \Cached\ signals that a domain object's title should be cached, while \CachedWithCacheSettings\ allows fine-tuning the cache behavior by specifying the expiry duration (in minutes) and maximum number of entries. These interfaces work in conjunction with \DomainObjectLayout\#titleUiEvent()\ to enable configurable title caching for application entities.

extensions/core/titlecache/applib · high confidence

New viewer-commons applib services and UI models

This change introduces the \viewers/commons/applib\ module, providing shared UI model classes and services for the application's interface. It adds a new Spring module (\CausewayModuleViewerCommonsApplib\) that registers prototyping mixins for user impersonation (\Object\_impersonate\ and \Object\_impersonateWithRoles\), allowing developers to switch user accounts during testing. Additionally, it defines the core UI data structures for the application's chrome: \BrandingUiModel\ and \BrandingUiService\ for logo/name display, \HeaderUiModel\ and \HeaderUiService\ for the top header, \UserProfileUiModel\ and \UserProfileUiService\ for user identity, and a comprehensive menu model (\MenuAction\, \MenuDropdown\, \NavbarUiModel\, etc.) with a \MenuVisitor\ to traverse the navigation bar structure.

viewers/commons/applib · high confidence

New viewer-commons model utilities for UI decoration, error handling, and webjar resource lookup

The viewer-commons model module introduces several new model classes and interfaces to support the UI rendering layer. It adds decorator interfaces (Confirm, Disabling, FormLabel, Prototyping, Tooltip) with their corresponding decoration models to standardize how UI components are enhanced. It introduces an ExceptionModel to structure error reporting, distinguishing between authorization, recognized, and unrecognized exceptions. A new UiString record allows components to distinguish between plain text and HTML markup. Additionally, it provides a JarManifestModel to aggregate JAR manifest attributes for the application's 'About' view, and a WebjarEnumerator utility that dynamically scans the classpath to resolve webjar resource paths without hardcoding version strings.

causeway-viewer-commons-model · high confidence

New web component viewer foundation and documentation

The viewers area now includes a new web component viewer foundation module, providing framework-neutral browser components backed by the rich GraphQL schema. This foundation includes a GraphQL client, coordinated application menus, object contexts, property editors, collections, and a PDF reader, all packaged as ECMAScript modules. The change also adds comprehensive documentation (README, USAGE, antora guides) and sample applications (HTMX, Vue, plain HTML) to demonstrate integration, alongside pinned PDF.js assets for document viewing.

viewers · high confidence

PDF.js viewer configuration via metamodel facets

The PDF.js viewer extension now supports configuring the viewer's initial state (page, scale, height) through the metamodel. This is achieved by introducing a \PdfJsViewerFacet\ and a corresponding \PdfJsViewerFacetFromAnnotationFactory\ that processes the \@PdfJsViewer\ annotation on properties or mixin types. The facet allows runtime \PdfJsViewerAdvisor\ implementations to override these default configuration values, enabling dynamic customization of the viewer's appearance and behavior based on the context.

extensions/vw/pdfjs/metamodel · high confidence

PDF.js viewer extension introduces configurable annotation and module

The PDF.js viewer extension now provides a new \@PdfJsViewer\ annotation that can be applied to properties or parameters of type Blob to render them using the PDF.js viewer, with configurable initial page, scale, and height. A new \CausewayModuleExtPdfjsApplib\ module registers the \PdfJsViewerAdvisor\ for dependency injection, and supporting configuration classes (\PdfJsConfig\, \Scale\) are introduced to manage viewer settings.

extensions/vw/pdfjs/applib · high confidence

Querydsl-based autocomplete support for domain objects and properties

This change introduces a new metamodel module that enables autocomplete functionality for domain objects and properties using Querydsl. It adds a Spring configuration module that wires in an AutoCompleteGeneratedQueryMetaModelRefiner, which registers an AutoCompleteGeneratedQueryFacetFactory. This factory processes @DomainObject and @Property annotations to create AutoCompleteUsingQueryDslFacet instances, allowing developers to configure searchable properties, result limits, and minimum input lengths for autocomplete features via Querydsl predicates.

persistence/querydsl/metamodel · high confidence

Repository initialization with Apache Causeway project scaffolding

The repository has been initialized with the core Apache Causeway project structure, including the root README, CONTRIBUTING guidelines, and the project's Apache License 2.0. Configuration files for version control (.gitignore, .gitattributes), IDE consistency (.editorconfig), and Apache infrastructure (.asf.yaml) have been added. Documentation tooling is configured via .asciidoctorconfig and causeway-tooling.yml, while CI/CD and development workflows are supported by build scripts (build-site.sh) and an .mcp.json file for integrated development tools.

(repo-wide) · high confidence

Secman authentication bridge for Vue webcomponents viewer

The Vue webcomponents viewer now supports authentication via the Secman extension. This change introduces a dedicated Spring Security configuration that registers a Secman-backed user details service and authentication provider, enabling users to log in using their Secman credentials. The implementation includes a custom authentication entry point to handle unauthenticated requests for GraphQL and authentication context endpoints, and an authentication converter that maps Secman user details (including roles, multi-tenancy tokens, and locale preferences) to the application's user memento.

causeway-viewer-webcomponents-vue-security-secman, viewers/webcomponents/security-secman · high confidence

Secman integration now enriches user sessions with roles and preferences

The security-manager integration now populates the user session with roles and locale settings defined in the application user store. The new UserMementoRefiner enriches the session with multi-tenancy tokens, language, number, and time formats, and adds roles from the application user. Additionally, the AuthorizorSecman component implements authorization checks against these application permissions and ensures the logout action is always visible and usable.

causeway-extensions-secman-integration · high confidence

Security Manager (SecMan) application library scaffolding

The \extensions/security/secman/applib\ module has been introduced as the application-layer foundation for the Security Manager extension. This change adds the core domain model for managing application permissions, roles, tenancies, and users, including the \ApplicationPermission\ interface and its associated \ApplicationPermissionRepository\ for querying and persisting security rules. It also provides the \ApplicationOrphanedPermissionManager\ view model to identify and relocate permissions that no longer map to existing application features, and registers the necessary Spring configuration, menus, and mixins to expose these security management capabilities within the Causeway application.

extensions/security/secman/applib · high confidence

Session log extension introduces activity tracking and querying

The Session Log extension now provides a new domain model and UI for tracking user sessions. A new SessionLogEntry entity records login and logout events, including session GUIDs, HTTP session IDs, and timestamps. The SessionLogMenu service exposes actions in the Activity secondary menu to list active sessions or search logs by username and date range. Additionally, a mixin contributes a recent sessions collection to any domain object implementing HasUsername, allowing users to view recent activity directly on user profiles.

extensions/security/sessionlog/applib · high confidence

Spring Security integration module added

A new Spring Security module has been introduced to handle authentication and authorization within the application. This module registers a Spring Security filter that intercepts requests, extracts the authenticated user from the Spring Security context, and converts it into a Causeway UserMemento using pluggable converters (supporting AuthenticatedPrincipal, String, and UserDetails). It also includes a configuration bean that allows administrators to disable Spring's CSRF protection filters if needed, and provides an Authenticator service that relies on the pre-established Spring Security context for user identity.

security/spring · high confidence

Spring Security integration module and authentication conversion SPI

The security-spring module now includes a new WebModule that automatically registers the Spring Security filter on all URL patterns, enabling Spring Security integration. Additionally, a new AuthenticationConverter SPI is introduced to allow converting Spring Authentication objects into Causeway UserMementos, supporting a chain-of-responsibility pattern with configurable priority.

causeway-security-spring · high confidence

Website assets now include Algolia search and optimized font caching

The website now features a full-text search capability powered by Algolia, implemented via the new \docsearch.min.js\ library and corresponding UI elements in \index.html\. Additionally, a new \\_headers\ configuration file has been introduced to set a one-week cache duration for font assets, improving load performance for site visitors.

antora/supplemental-ui · high confidence

Wicket UI support for Vega value types

This change introduces the Wicket-based rendering components for the Vega value type, enabling users to view Vega and Vega-Lite visualizations directly within the application's web interface. It adds a new module (org.apache.causeway.valuetypes.vega.ui.wkt) that registers Spring configurations to wire up parented and standalone panel factories for the Vega type. The implementation includes a custom Wicket component (VegaComponentWkt) that dynamically loads the necessary JavaScript libraries (Vega, Vega-Lite, and Vega-Embed) via WebJars based on the schema type, ensuring the correct visualization engine is rendered in the browser.

valuetypes/asciidoc/ui/wicket, valuetypes/vega/ui/wicket · high confidence

Wicket viewer adds 'Clear Hints' action to reset object presentation

The Wicket viewer now includes a new 'Clear Hints' action (accessible via the metadata panel) that allows users to reset the presentation of a domain object to its initial state. This clears any stored UI preferences such as tab selections, column sorting, or pagination settings, ensuring the object is rendered fresh upon the next visit. This functionality is implemented via the new \Object\_clearHints\ mixin in the \viewers/wicket/applib\ module, which integrates with the existing \HintStore\ and \BookmarkService\.

viewers/wicket/applib · high confidence

Architecture

Metamodel module migrated to Java Platform Module System (JPMS)

The core/metamodel module has been converted to a Java module, introducing a module-info.java that explicitly declares its public API exports and dependencies. This change enforces encapsulation by restricting access to internal implementation classes and defining clear boundaries for consumers such as the runtime services, viewers (Wicket, RESTful Objects, GraphQL), and persistence commons. The module requires transitive dependencies on applib, commons, config, and schema, while explicitly requiring optional modules like security.api and JSpecify.

api/applib, core/metamodel, viewers/wicket/ui · high confidence

Migrate viewer-commons services to a new module

The viewer-commons services (branding, header, menu, user profile, and translations) have been moved into a new \viewers/commons/services\ module. This change introduces a dedicated Spring configuration module (\CausewayModuleViewerCommonsServices\) that wires the default implementations of these UI services, making them available as a reusable, modular component for other viewers.

viewers/commons/services · high confidence

Migration of core runtime services to a dedicated module with Jakarta EE and OpenTelemetry support

The core runtime services have been consolidated into a new \core/runtimeservices\ module, introducing a formal Java Platform Module System (JPMS) structure that exports service packages and declares dependencies on Jakarta Activation, Mail, and Annotation APIs. This migration includes the introduction of OpenTelemetry integration for observing action invocations and property edits, a configurable HMAC authority for bookmark security (supporting environment variable secrets), and the adoption of Jakarta EE annotations for dependency injection and service prioritization across the runtime layer.

core/runtimeservices · high confidence

New viewer-commons model module for shared UI domain objects

A new \org.apache.causeway.viewer.commons.model\ module has been introduced to centralize shared UI model interfaces used across viewers. This module defines the core UI model hierarchy, including the \UiModel\ marker interface, and specific models for actions (\UiActionForm\, \HasActionInteraction\, \HasManagedAction\) and attributes (\UiAttribute\, \UiParameter\, \UiProperty\). It also provides component type definitions (\UiComponentType\) for rendering various UI elements like domain objects, collections, and forms, along with decorator interfaces (\IconDecorator\, \DangerDecorator\) and CSS resource definitions. This refactoring consolidates model logic previously scattered across viewer implementations into a common library.

viewers/commons/model · high confidence

Restful Objects rendering module migrated to Java Platform Module System

The Restful Objects rendering component has been converted to a Java module (org.apache.causeway.viewer.restfulobjects.rendering), introducing explicit module boundaries and dependencies. This change requires consumers to declare a dependency on the new module rather than the previous classpath arrangement. The module exports its core rendering packages (context, domainobjects, domaintypes, exhandling, service, util) and declares required dependencies on Spring, Jackson, Swagger, and internal Causeway modules, establishing the structural foundation for the rendering layer.

viewers/restfulobjects/rendering · high confidence

Wicket Viewer restructured into modular Spring configuration and services

The Wicket Viewer has been reorganized to use Spring Boot auto-configuration, introducing a central \CausewayModuleViewerWicketViewer\ configuration class that wires together UI modules, initialization configs (such as Bootstrap, jQuery, and Select2), and core services. This change includes new Wicket-specific implementations for services like \BookmarkUiService\, \HintStore\, and \ObjectRenderService\, as well as a custom \ResourceSettings\ to prioritize application-specific i18n properties. The refactoring also updates the authentication session handling in \AuthenticatedWebSessionForCauseway\ and establishes a default page registry in \PageClassListDefault\ to map logical page types to their Wicket implementations.

viewers/wicket/viewer · high confidence

Wicket viewer model module is extracted and modularized

The Wicket viewer's model layer is now a standalone Java module (org.apache.causeway.viewer.wicket.model) with its own module-info.java, providing a clean separation of concerns. This new module exposes packages for core models, interactions, collections, and UI hints, and declares dependencies on the core application library, common model abstractions, and Wicket. It also introduces a Spring configuration module (CausewayModuleViewerWicketModel) to wire the model layer with the core webapp module, establishing the foundation for the viewer's data and interaction models.

viewers/wicket/model · high confidence

Behavioural changes

1 commit (0 fixes) modifying antora/components/refguide/modules/applib-classes/images, antora/components/refguide/modules/applib-methods/images

A change to existing behaviour in antora/components/refguide/modules/applib-classes/images, antora/components/refguide/modules/applib-methods/images — 1 commit, 14 files.

antora/components/refguide/modules/applib-classes/images, antora/components/refguide/modules/applib-methods/images · medium confidence · unverified

2 commits (0 fixes) modifying antora/components/refguide/modules/applib-svc/images

A change to existing behaviour in antora/components/refguide/modules/applib-svc/images — 2 commits, 11 files.

antora/components/conguide/modules/ROOT/images, antora/components/refguide/modules/applib-svc/images · medium confidence · unverified

Adds Java module descriptor for the Asciidoctorj application library

The Asciidoctorj application library now includes a module-info.java file, formally declaring its module name (org.apache.causeway.valuetypes.asciidoc.applib) and its dependencies. This enables the library to be used within the Java Platform Module System (JPMS), exposing packages for value types, JAXB, and the main library, while requiring static access to Lombok and standard dependencies like Jakarta Inject, JAXB, Spring, and Asciidoctorj.

valuetypes/asciidoc/applib · high confidence

Apache Causeway user guide restructured for Antora

The user guide documentation has been reorganized into the Antora component structure, introducing a new navigation file and configuration. The content has been updated to reflect the project's rebranding from 'Isis' to 'Apache Causeway' and the migration from JDO to JPA persistence, with references to legacy technologies like JScience and Bootstrap 3 removed. The guide now covers core domain concepts including entities, services, view models, and modularity, alongside advanced topics such as business rules, events, and value types.

antora/components/userguide/modules/ROOT · high confidence

ApplicationUser is now an interface with explicit command/execution publishing

The ApplicationUser domain model has been converted from an abstract class to an interface, which changes how the framework handles its lifecycle and permission mapping. Additionally, the mixin action for updating user locale (ApplicationUser\_updateLocale) now explicitly specifies commandPublishing and executionPublishing as NOT\_SPECIFIED, ensuring consistent event publishing behavior for this user-setting operation.

causeway-extensions-secman-applib · high confidence

AsciiDoc value type now renders with syntax highlighting and pretty-printed XML for DTOs

The metamodel for the AsciiDoc value type now includes dedicated semantics classes that provide syntax highlighting (using Prism themes) for AsciiDoc content in the UI. Additionally, the Change, Command, and Interaction DTO value semantics have been extended to render their XML payloads as pretty-printed HTML with syntax highlighting, improving readability of these objects in the application interface.

valuetypes/asciidoc/metamodel · high confidence

Audit trail extension refactored for Causeway 2.0 with new UI and query capabilities

The audit trail application library has been restructured for version 2.0, introducing a new 'Activity' menu under the secondary menu bar that allows users to search for audit records by date range or view the most recent entries. The domain model now uses an interface for \AuditTrailEntry\ and includes mixins to display recent audit entries and the originating command for specific domain objects. Additionally, the repository now supports querying audit entries by username, and the UI layout has been updated to use Bootstrap 5 namespaces.

extensions/security/audittrail/applib · high confidence

Audit trail persistence layer now supports querying by username

The JPA persistence implementation for the audit trail has been updated to include new named queries that allow filtering audit entries by the username who performed the action. Specifically, the \AuditTrailEntry\ entity now supports lookups by username combined with timestamp ranges (before, after, between) and in combination with specific target objects, enabling users to trace activity for specific accounts more effectively.

causeway-extensions-audittrail-persistence-jpa · high confidence

The audit trail extension now persists audit entries using JPA (specifically EclipseLink) instead of its previous storage mechanism. This change introduces a new \AuditTrailEntry\ entity and repository, along with a Spring Boot module configuration that handles entity scanning and provides a teardown fixture for test environments. Users benefit from standard JPA-based persistence for audit logs, ensuring compatibility with existing JPA infrastructure and simplifying database schema management through automatic schema creation.

extensions/security/audittrail/persistence-jpa · high confidence

ByteBuddy codegen module migrated to Java Platform Module System (JPMS)

The core/codegen-bytebuddy module now exposes its functionality as a named JPMS module (org.apache.causeway.core.codegen.bytebuddy). This change introduces a module-info.java that explicitly exports the services and core packages, and declares static dependencies on Lombok alongside runtime requirements for ByteBuddy, the Causeway commons, and Spring Context/Core. The module's Spring configuration class (CausewayModuleCoreCodegenByteBuddy) remains in place to wire the ByteBuddy-based proxy factory service, ensuring the codegen capability is available to consumers while adhering to the new module structure.

core/codegen-bytebuddy · high confidence

Centralized Wicket component factory registration

The Wicket viewer now uses a centralized Spring configuration class, ComponentFactoryConfigWkt, to register built-in UI component factories (such as those for entities, collections, properties, and action links) alongside any plugin-provided factories. This replaces the previous ComponentFactoryRegistrar mechanism, consolidating the wiring of the component factory registry and ensuring a consistent, single point of configuration for the viewer's UI components.

causeway-viewer-wicket-viewer · high confidence

Command log persistence model and replay result mapping

The JPA persistence layer for the command log extension now includes a comprehensive domain model for command log entries, featuring new database indexes and named queries to support efficient lookups by interaction ID, target, timestamp ranges, and background execution status. Additionally, a new \CommandReplayResultMapping\ entity has been introduced to persist the mapping between recorded and actual bookmarks during command replay operations, enabling the system to track and identify discrepancies in replayed command outcomes.

causeway-extensions-commandlog-persistence-jpa · high confidence

Core configuration module restructured as a dedicated Java module with type-safe Spring Boot properties

The core configuration capabilities have been consolidated into a new \org.apache.causeway.core.config\ module. This introduces a unified \CausewayConfiguration\ record that centralizes application settings, replacing the previous scattered configuration approach. The module now provides type-safe configuration support for Eclipselink persistence (including weaving, DDL generation, and JDBC settings) and email services via dedicated \EclipselinkConfiguration\ and \EmailConfiguration\ records. Additionally, the framework's bean discovery and classification logic has been refactored into this module, introducing \CausewayBeanFactoryPostProcessor\ and \CausewayBeanTypeClassifier\ to manage how domain objects, services, and view models are identified and registered within the Spring context.

core/config · high confidence

Core runtime module restructured with new flush management and Xray configuration

The core runtime module has been reorganized into a new Java module (org.apache.causeway.core.runtime) that wires together the metamodel, interaction, and transaction sub-modules. This update introduces a FlushMgmt utility to control auto-flush suppression via ThreadLocal state, and adds an XrayInitializerService that populates the Xray debug view with environment and primary configuration properties during metamodel loading.

core/runtime · high confidence

Core security module refactored for v2 with modularized authentication and authorization

The core security module has been restructured for version 2, introducing a new Java module (org.apache.causeway.security.api) that exports authentication and authorization services. This change includes a refactored authentication flow with new interfaces like AuthenticationRequest and Authenticator, a centralized AuthorizationManager that now considers action semantics for safer permission checks, and dedicated services for login, logout, and user session management. The module also adds test coverage for session encodability to ensure reliable serialization of user contexts.

core/security · high confidence

Documentation of Apache Causeway standard XSD schemas

The documentation now includes detailed reference pages for the standard XSD schemas used for enterprise integration: the metamodel (mml), command (cmd), interaction execution (ixn), and changes (chg) schemas, along with the common schema types they share. These pages describe the XML structures, namespaces, and DTOs (such as \oidDto\, \commandDto\, and \changesDto\) that facilitate exporting the internal metamodel and capturing user intentions and execution results for auditing or replication. The documentation also notes that the legacy 'aim' schema was removed in version 1.13.0 and replaced by the cmd and ixn schemas.

api/schema/src/main/adoc/modules/schema · high confidence

Excel extension API restructured for Causeway 2.0

The Excel extension's application library has been completely rewritten for version 2.0, introducing a new service-oriented API. Users can now export domain objects to Excel spreadsheets and import them back using the new \ExcelService\, which supports both standard data grids and pivot tables. The API provides fine-grained control over worksheet generation via \WorksheetSpec\ and \WorksheetContent\, allowing for multiple sheets and custom configurations. Import modes (\STRICT\ and \RELAXED\) allow users to handle malformed data gracefully. New annotations (\@PivotRow\, \@PivotColumn\, \@PivotValue\, \@HyperLink\) enable declarative configuration of pivot table structures and hyperlink formatting directly on domain model properties.

extensions/core/excel/applib · high confidence

Excel fixture demo now uses JPA instead of JDO

The Excel fixture demo application has migrated its data layer from JDO to JPA. The \ExcelDemoToDoItem\ domain model now uses JPA annotations (e.g., \@Entity\, \@Table\) and the \ExcelDemoToDoItemMenu\ service uses JPA-compatible repository queries. This change aligns the demo with the platform's shift away from JDO, ensuring the Excel upload and fixture scripts work correctly with the new persistence model.

causeway-extensions-excel-fixtures · high confidence

Execution log persistence model migrated to JPA 3.1 and JSpecify

The JPA persistence layer for the Execution Log extension has been updated to use Jakarta EE 10 (JPA 3.1) annotations, replacing the older javax.persistence imports. The domain model classes, including ExecutionLogEntry and its composite key ExecutionLogEntryPK, now rely on JSpecify annotations (org.jspecify.annotations.NonNull) instead of Lombok's NonNull for null-safety metadata. This change ensures compatibility with modern Jakarta-based persistence providers and aligns the extension's null-handling conventions with the broader framework migration.

causeway-extensions-executionlog-persistence-jpa · high confidence

FullCalendar extension introduces programmatic calendar interfaces and SPI

The fullcalendar application library now provides the Calendarable and CalendarEventable interfaces, with methods like getCalendarNames() and toCalendarEvent() marked as @Programmatic to exclude them from the user interface. It also adds a CalendarableDereferencingService SPI, allowing calendar markers to open the owner object rather than the calendar object itself, and includes a default HTML template for rendering calendar event cards.

extensions/vw/fullcalendar/applib · high confidence

FullCalendar integration introduces new callback data models using Java 8 time

The FullCalendar Wicket integration now includes new callback parameter classes—DroppedEvent, SelectedRange, and View—that utilize the modern java.time API (LocalDateTime, LocalDate) instead of legacy date libraries. This change supports the reorganization of the fullcalendar package structure and ensures that event dropping, range selection, and view state data are handled with standard Java 8 date-time types, aligning with the removal of Joda Time support.

causeway-extensions-fullcalendar-wicket-integration · high confidence

Home page UI updated with Bootstrap 4 and Animate.css

The home page UI now utilizes Bootstrap v4.0.0 for layout and styling, replacing the previous version, and includes Animate.css v3.5.2 to enable CSS-based animations on the page elements.

antora/supplemental-ui/js/home · high confidence

Homepage styling and branding updates

The homepage CSS has been updated to apply the Causeway brand palette (purple, cyan, pink, blue, yellow) and fix visual issues. Specific changes include correcting the vertical positioning of the logo and text in the header, adjusting the z-index of menu items to prevent overlapping, and adding copyright headers to the CSS files. The site now uses the 'Reveal' theme base with custom ISIS and Causeway color variables.

antora/supplemental-ui/css/home · high confidence

Introduces OpenSpec workflow skills and operational standards

Adds a suite of new AI agent skills and documentation to standardize the development workflow. The \.pi/prompts/\ directory now includes \opsx-explore\, \opsx-propose\, \opsx-apply\, and \opsx-archive\ to guide users through the OpenSpec change lifecycle, from initial investigation and proposal to implementation and final archiving. Operational standards are defined in \.pi/standards/\ for commit message formatting and OpenSpec workflow rules, while a new retrospective note in \.pi/notes/\ provides token-saving best practices for HTMX viewer sessions. A symlink in \.pi/skills\ now points to the shared agent skills directory.

.pi · high confidence

JPA applib module migrated to Jakarta EE and Java Modules

The JPA application library has been migrated to the Jakarta EE namespace (e.g., \jakarta.persistence\, \jakarta.inject\) and structured as a Java Platform Module System (JPMS) module. This includes the addition of \module-info.java\ to define module dependencies and exports, and the renaming of core classes such as \CausewayModulePersistenceJpaApplib\ and \CausewayEntityListener\ to reflect the new package structure. The \CausewayEntityListener\ now handles JPA lifecycle events (like \@PostLoad\) using the updated Jakarta annotations and integrates with the new \JpaSupportService\ to manage \EntityManager\ access and object lifecycle publishing.

persistence/jpa/applib · high confidence

JPA persistence integration module refactored to Jakarta EE and Java Modules

The JPA persistence integration module has been migrated to the Jakarta EE namespace (jakarta.persistence, jakarta.inject) and structured as a Java Platform Module System (JPMS) module. This change updates the underlying persistence stack to use Jakarta-standard APIs, ensuring compatibility with modern Spring Boot and Jakarta-based ecosystems, while also exposing specific type converters for Java time, util, AWT, and Causeway schema types via the new module exports.

persistence/jpa/integration · high confidence

JPA persistence models for security domain entities are re-implemented

The JPA persistence layer for the security manager extension has been updated with new entity implementations for ApplicationPermission, ApplicationRole, ApplicationTenancy, and ApplicationUser. These classes now implement the corresponding interfaces from the application library and include specific JPA annotations, named queries, and relationships (such as the many-to-many link between roles and users) to support the underlying data storage.

causeway-extensions-secman-persistence-jpa · high confidence

Migrate Markdown value-type UI to Wicket

The Wicket UI layer for the Markdown value-type has been migrated to a new module structure. This change introduces a dedicated Spring configuration module that wires up the necessary panel factories, enabling both parented and standalone rendering of Markdown content within Wicket-based views. The implementation includes a specific Wicket component and factory classes that handle the client-side JavaScript required for syntax highlighting, ensuring consistent display of Markdown attributes in the user interface.

valuetypes/markdown/ui/wicket · high confidence

Migrate RESTful Objects viewer from RestEasy to Spring MVC

The RESTful Objects viewer runtime has switched its underlying web framework from JBoss RestEasy to Spring MVC (Spring Boot). This change replaces the previous servlet-based interaction filter with a Spring-managed filter component, aligning the viewer with the platform's standard Spring-based architecture. Users should expect the REST API endpoints to remain functionally equivalent, but the internal request handling and configuration mechanisms are now driven by Spring conventions rather than RestEasy annotations.

causeway-viewer-restfulobjects-viewer · high confidence

Migrate to Jackson 3.x and update JSON handling

The RestfulObjects viewer library has been upgraded to use Jackson 3.x, replacing the previous Jackson version. This change updates the underlying JSON serialization and deserialization infrastructure, including the \JsonRepresentation\ class which now relies on \tools.jackson.databind\ types. Additionally, support for Joda Time has been removed, and the codebase has been refactored to use JSpecify annotations for nullability checks instead of Spring's annotations.

causeway-viewer-restfulobjects-applib · high confidence

Migrated AsciiDoc and Markdown value types to JPA persistence

The AsciiDoc and Markdown value types now include dedicated JPA persistence modules that automatically handle database storage. These modules provide JPA \AttributeConverter\ implementations (\CausewayAsciiDocConverter\ and \CausewayMarkdownConverter\) that transparently convert the rich value types to and from String columns in the database. The changes also introduce Spring Boot auto-configuration modules that register these converters and scan for them, ensuring that applications using these value types no longer need manual persistence setup.

valuetypes/asciidoc/persistence-jpa, valuetypes/markdown/persistence-jpa · high confidence

The EclipseLink persistence module has been migrated to the Jakarta EE namespace (replacing javax.\* with jakarta.\* imports) and converted to a Java Platform Module System (JPMS) module. This change updates the module-info.java to declare dependencies on jakarta.persistence, jakarta.inject, and other Jakarta libraries, and refactors internal classes (such as the JPA configuration, exception translation, and metadata services) to use the new namespaces. Users relying on this module will need to ensure their environment supports the Jakarta EE 9+ APIs and JPMS.

persistence/jpa/eclipselink · high confidence

The layout configuration system now includes formal XSD schemas for defining UI structure, located in the \antora/supplemental-ui/applib/layout\ directory. These schemas define the structure for core components (actions, properties, field sets, domain objects), Bootstrap 3 grid layouts (rows, columns, tabs), link definitions, and menu bar configurations. This provides a validated contract for how layout XML files should be structured, enabling better tooling support and ensuring consistency in how application interfaces are described.

antora/supplemental-ui/applib/layout · high confidence

PDF.js viewer integration updated for v4.x/v5.x and Wicket resource handling

The Wicket integration for the PDF.js viewer has been updated to support PDF.js versions 4.x and 5.x. This change introduces a new module-based resource loading strategy (using .mjs files) and configures the Wicket resource guard to allow access to necessary PDF.js assets like .bcmap and .mjs files. The integration now dynamically initializes the PDF viewer with specific worker and cmap URLs, ensuring correct rendering and printing functionality within the Wicket application.

extensions/vw/pdfjs/wicket/integration · high confidence

Programmatic ServletContext initialization replaces web.xml

The web application now initializes its servlet context programmatically via the new CausewayWebAppContextInitializer, eliminating the need for a web.xml descriptor. This change introduces a structured, two-phase startup process: first, it prepares the WebModuleContext, and second, it initializes registered WebModules (such as the LogOn Exception Logger and Template Resources modules) to register their filters and servlets. This modular approach ensures that web components are set up in a defined order and allows for cleaner configuration management within the application.

causeway-core-webapp · high confidence

Refactor authentication core and standard code generator implementation

The authentication module introduces an abstract base class, AuthenticationRequestAbstract, to centralize the management of user names and associated roles, while the standard authentication package now provides a default RandomCodeGeneratorDefault implementation that generates secure random codes using a fixed character set and a minimum length constraint.

causeway-core-security · medium confidence

The metamodel now uses a sealed interface for Consent with distinct Allow and Veto states, where Veto reasons are strongly typed via a new VetoReason record that distinguishes between SECURITY and PROGRAMMING\_MODEL origins and controls UI display hints (such as when to show a ban icon). Additionally, interaction execution is managed through a new InteractionCarrierDefault record and an InteractionLayerStack, which handle the lifecycle of interactions and their nested executions using a thread-local stack, replacing previous ad-hoc tracking mechanisms.

causeway-core-metamodel · high confidence

Refactors proxying internals to use records and capture invocation origin

The core runtime's proxying mechanism has been refactored to improve clarity and maintainability. The \WrappingObject\ interface now defines a new \Origin\ record to explicitly store the underlying POJO, any associated managed mixee, and the \SyncControl\ state, ensuring this context is preserved on proxy creation. Additionally, a new \WrapperInvocationHandler\ interface introduces a \WrapperInvocation\ record to encapsulate method invocation details (target, method, arguments, and origin), replacing previous abstract handler implementations. These changes streamline how the framework handles object wrapping and method interception without altering the external API.

causeway-core-runtime · high confidence

Refactors transaction scoping to prevent stack overflows and adds change-tracking events

The transaction module introduces new event types, PostStoreEvent and PreStoreEvent, to support change tracking, and significantly refactors the StackedTransactionScope implementation. This refactoring replaces the previous object-holding mechanism with a UUID-based nesting stack to manage transaction scopes, specifically addressing and preventing stack overflow errors that could occur during nested transaction handling and after-completion callbacks.

causeway-core-transaction · high confidence

Removal of CVS administrative configuration files

The CVS administrative files in the repository root (CVSROOT) have been deleted. This includes configuration and hook scripts such as config, commitinfo, loginfo, notify, rcsinfo, taginfo, verifymsg, modules, cvswrappers, editinfo, checkoutlist, and commitinfo. These files previously controlled repository behavior including pre-commit checks, log message verification, notification routing, tag validation, and module definitions; their removal means these custom CVS server-side hooks and configurations are no longer active.

CVSROOT · high confidence

Rename IsisModule classes to CausewayModule

The module configuration class for the Flyway extension has been renamed from IsisModuleExtFlywayImpl to CausewayModuleExtFlywayImpl, reflecting the project's rebranding from Isis to Causeway. This change updates the Java class name and package structure to align with the new naming convention, ensuring consistency across the codebase.

extensions/core/flyway/impl · high confidence

Restful Objects applib migrated to Spring REST and Jackson 3

The Restful Objects application library has been refactored to replace the previous JBoss RestEasy implementation with Spring's RestController-based architecture. This change introduces a new Java module definition and updates the underlying JSON serialization to Jackson 3.x (tools.jackson), while also removing legacy Joda Time support. For users, this represents a significant backend shift in how the REST API is served and serialized, requiring compatibility with the new Spring and Jackson dependencies.

viewers/restfulobjects/applib · high confidence

Restful Objects viewer documentation restructured and renamed to Apache Causeway

The documentation for the Restful Objects viewer has been reorganized into a new Antora module structure under \viewers/restfulobjects/adoc/modules/ROOT\. All references to the previous 'Isis' project name have been updated to 'Apache Causeway', and the documentation now includes new pages for the REST Client, content negotiation (including the simplified v2 profile), layout resources, and hints and tips. This restructure improves navigation and aligns the viewer's documentation with the broader Apache Causeway project branding and architecture.

viewers/restfulobjects/adoc/modules/ROOT · high confidence

Restful Objects viewer migrates to Spring REST controllers

The Restful Objects viewer implementation has been refactored to use Spring's @RestController and @RestControllerAdvice annotations instead of the previous RestEasy (JBoss) framework. This change introduces Spring-based exception handling via ExceptionMapperForRestfulObjects and registers the viewer's REST resources (such as DomainObjectResourceServerside, DomainServiceResourceServerside, and HomePageResourceServerside) as Spring components within the new CausewayModuleViewerRestfulObjectsViewer configuration module.

viewers/restfulobjects/viewer · high confidence

Restored Isis v1 namespace schemas for changes and commands

The XML schemas for the Isis v1 namespaces (chg and cmd) have been restored to the supplemental UI documentation, now hosted under the https://causeway.apache.org/schema-v1 path. This update includes versioned schema definitions (e.g., chg-1.0.xsd through chg-2.0.xsd and cmd-1.0.xsd through cmd-2.0.xsd) that define the structure for transaction changes and command invocations, ensuring that documentation for these specific API contracts is available for users.

antora/supplemental-ui/schema-v1 · high confidence

Schema module migrated to Jakarta EE and v2.0

The schema module has been updated to use the Jakarta XML Binding (JAXB) API instead of the legacy Java EE javax.xml.bind, requiring the jakarta.xml.bind and jakarta.inject dependencies. Additionally, the internal XML schemas (XSDs) and generated Java packages have been bumped to version 2.0 (e.g., org.apache.causeway.schema.cmd.v2), introducing new DTO structures for commands, interactions, changes, and the metamodel that align with the framework's v2.0 release.

api/schema · high confidence

Secman integration module introduces v1 compatibility for permission evaluation

The secman integration module now includes an SPI for transforming ApplicationFeatureIds before permission evaluation, with a default identity transformer and a v1-compatibility transformer that converts logical type names to physical package names. This allows existing v1-style permissions to work without migration. The module also wires up the Secman authenticator, authorization facets, and other integration services via Spring auto-configuration.

extensions/security/secman/integration · high confidence

Security documentation restructured for Apache Causeway

The security guide documentation has been reorganized to align with the Apache Causeway rebranding and updated navigation structure. New files establish a clear hierarchy, including an overview of the authentication and authorization SPIs, details on permissions and auditing, and specific usage instructions for the Wicket and Restful Objects viewers. The navigation includes links to core security modules (bypass, keycloak, spring) and extensions (SecMan, Audit Trail, Spring OAuth2, Session Log), ensuring users can easily find configuration and implementation details for securing their applications.

security/adoc/modules/ROOT · high confidence

Server-side Prism syntax highlighting with theme support

The viewer-commons prism module now performs syntax highlighting server-side using GraalJS, ensuring that adoc rendering looks consistent between server and client. This change introduces a new module structure (module-info.java) and utility classes (PrismUtils, PrismTheme) to manage Prism resources and themes. Users can now select from multiple Prism themes (Default, Coy, Dark, etc.), with the Coy theme including a specific CSS override to remove box shadows from code blocks.

viewers/commons/prism · high confidence

Server-side syntax highlighting for code blocks

The viewer now performs syntax highlighting for code blocks on the server side using the Prism library and GraalJS, ensuring that the visual appearance of highlighted code matches the previous client-side rendering. This change introduces a new standalone highlighting engine within the commons prism module that processes HTML content, identifies code nodes by their language class, and applies syntax highlighting before the content is sent to the browser.

causeway-viewer-commons-prism · high confidence

Session log persistence model refactored to use JPA interfaces and embedded IDs

The JPA persistence layer for the session log extension has been updated to align with the application's domain model changes. The \SessionLogEntry\ entity now implements the \SessionLogEntry\ interface defined in the \applib\ module, ensuring consistency with the abstracted domain contract. Additionally, the primary key structure has been refactored to use an embedded \SessionLogEntryPK\ class, which includes a dedicated \Semantics\ component for value-based identification. This change supports the broader migration of domain objects to interface-based contracts and improves the structural integrity of the persisted session log data.

causeway-extensions-sessionlog-persistence-jpa · high confidence

The .codex/skills path is no longer a standalone directory but a symbolic link pointing to ../.agents/skills. This change consolidates skill definitions into the .agents directory, meaning any skills previously accessible via .codex/skills are now sourced from the shared .agents location.

.codex · high confidence

Standardized extension documentation structure and build configuration

This change introduces a consistent documentation and build scaffolding across all extensions. It adds \antora.yml\ configuration files to every extension module (including core, security, and view-layer extensions) to define their documentation metadata and navigation, ensuring they are properly indexed in the user guide. Additionally, \.build-jpa-enhance\ marker files are added to persistence-enabled extensions (such as commandlog, executionlog, and audittrail) to explicitly enable static weaving via profile activation rules in the parent POM, ensuring these modules are correctly processed during the build.

extensions · high confidence

Transaction module restructured for Jakarta EE and Spring integration

The core/transaction module has been reorganized into a dedicated Java module (org.apache.causeway.core.transaction) with explicit exports for change tracking and scope services. This change introduces a new @TransactionScope annotation and a BeanFactoryPostProcessor to register a StackedTransactionScope in Spring, enabling transaction-scoped beans. It also adds a TimestampService that automatically updates OnUpdatedBy and OnUpdatedAt mixins on pre-store events, and refactors the entity change tracking interfaces (EntityChangeTracker, EntityChangesPublisher, EntityPropertyChangePublisher) to support publishing property changes and entity lifecycle events within the transaction scope.

core/transaction · high confidence

Updated home page branding assets and technology badges

The documentation site's home page visuals have been refreshed with new SVG assets. This includes updated logos for the Apache Wicket, Bootstrap, and Spring frameworks in the 'built-with' section, as well as new versions of the main Causeway logo (including a BMP-embedded SVG variant). These changes update the visual identity and technology stack representation on the landing page.

antora/supplemental-ui/img · high confidence

Updated published XSD schemas for commands and changes

The published XML schema definitions (XSDs) for the 'chg' (changes) and 'cmd' (commands) namespaces have been updated to their latest versions. This includes the introduction of new major versions (2.0) for both schemas, which rename fields such as 'transactionId' to 'interactionId' and 'user' to 'username', and add JAXB annotations for Java binding. Additionally, the 'cmd' schema has been extended with new minor versions (1.2–1.4) that introduce fields like 'logicalMemberIdentifier', 'timings', and 'userData' to support more detailed command metadata and custom data attachment.

antora/supplemental-ui/schema · high confidence

Updated reference documentation for the Causeway Applib module

The reference guide index for the Causeway application library (applib) has been regenerated and updated. This includes new or refreshed documentation pages for core module classes such as CausewayModuleApplib, Identifier, and ViewModel, as well as comprehensive updates to the API documentation for domain object annotations including @Action, @ActionLayout, @Collection, @CollectionLayout, @DomainObject, @DomainObjectLayout, and @DomainService. The changes reflect the current state of the applib API, ensuring the documentation accurately describes the available annotations, their attributes, and their usage for defining domain semantics and UI layout.

antora/components/refguide-index/modules/applib · high confidence

Wicket viewer model layer refactored to use Java records and new menu model

The Wicket viewer model layer has been significantly refactored to replace abstract classes and standard classes with immutable Java records, improving code clarity and reducing boilerplate. Key models such as ActionModel, BookmarkedPagesModel, VoidModel, WelcomeModel, and UiParameterWkt are now records. A new Menuable interface and its implementations (SectionSeparator, SectionLabel) have been introduced to standardize drop-down menu item modeling. Additionally, ActionModel now supports column-specific routing via the ColumnActionModifier enum, allowing actions originating from table columns to control whether the page reloads or opens in a new tab.

causeway-viewer-wicket-model · high confidence

Test coverage

Added ApprovalsOptions utility for standardized test approval configurations; Added ComparableContractTester for validating object ordering; Added Cucumber integration test support module; Added Cucumber-based regression tests for command execution and audit session persistence; Added JPA integration tests for command execution and audit session logging; Added JPA-specific regression tests for command, entity, execution, lifecycle, and property publishing; Added Wicket integration and logging tests for regression suite; Added architecture test support library for domain and module rules; Added comprehensive domain object fixture for testing all supported data types; Added documentation for the Fixture Scripts testing module; Added domain model classes for GraphQL test2; Added integration tests for GraphQL rich value and resource semantics; Added integration tests for layout facets and configuration; Added integration tests for the Excel extension module; Added integration tests for the FakeData module; Added integration tests for the RestfulObjects viewer; Added integration tests for the async wrapper factory; Added regression test for generic event publishing; Added regression test model for layout verification; Added regression tests for JPA observation policies and tracing entry points; Added regression tests for REST, LDAP, and metamodel performance; Added regression tests for REST-JPA integration; Added regression tests for action and collection interactions; Added regression tests for bootstrapping, configuration, and service injection; Added regression tests for wrapper interactions and mixin actions; Added test suite for metamodel facet factories and domain events; Added testing fixtures module for populating demo data; Added tests for CausewayForegroundTraceFilter; Added tests for CommandDto YAML serialization and replay import; Added tests for testing module documentation and fixture data; Added unit tests for UiObjectWkt hint management; Added unit tests for Wicket Viewer components and converters; Added value semantics regression tests; Documentation for integration test support utilities; Expanded GraphQL test domain with new entities, services, and value types; Expanded regression test domain for mixin validation and Wicket testing; Expanded regression tests for domain model validation and introspection; New FakeDataService for generating test data; New JPA persistence regression tests; New JPA+Wicket regression test application and tests; New fixtures testing library for prototyping and integration testing; New integration testing support library for Causeway; New regression test domain fixtures and validation models; New regression test for command, execution, and audit logging; New testing fixtures for Excel data import; New testing fixtures for execution parameters and persona builder scripts; New testing utilities for contract, POJO, and SOAP endpoint verification; New unit test support library for contract testing and assertions.

Dependencies

Routine dependency updates across 227 manifests

This release updates dependencies across 227 Maven manifests, including bumping Spring Boot from 3.2.0 to 3.2.1, upgrading Apache Wicket from 9.7.0 to 9.8.0, and updating the OWASP dependency-check-maven plugin from 9.0.4 to 9.0.5. Other notable changes include updates to Vaadin, JUnit, Lombok, and various internal framework libraries to their latest stable versions.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 41 → 40 (-1.0)
  • Rubric changed (rubric-2026.10.1 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 34 → 34 (-0.1)
  • Architecture 60 → 60 (+0.0)
  • Maturity 79 → 51 (-27.4)
  • Readiness 63 → 61 (-1.7)
  • Security 66 → 65 (-0.9)
  • Domain Modelling 50 → 52 (+1.8)
  • Accessibility 34 → 34 (-0.3)
  • Performance 64 → 60 (-4.3)

Resolved (17)

  • Documentation: no installation or build instructions (README.adoc)
  • Documentation: no installation or build instructions (viewers/webcomponents/foundation/vaadin-fields/README.adoc)
  • Documentation: no installation or build instructions (viewers/webcomponents/foundation/vaadin-menubar/README.adoc)
  • Documentation: no project overview (README.adoc)
  • Documentation: no project overview (viewers/webcomponents/foundation/vaadin-fields/README.adoc)
  • Documentation: no usage examples (README.adoc)
  • Duplicated block (12 lines × 2) (viewers/webcomponents/htmx-security-secman/src/main/java/org/apache/causeway/viewer/webcomponents/htmx/security/secman/HtmxSecmanSecurityConfiguration.java)
  • High: security finding (details withheld)
  • Low vulnerability: [GHSA redacted] (viewers/webcomponents/foundation/vaadin-actions/package-lock.json)
  • Medium: security finding (details withheld)
  • Near-duplicate member pair (32 shared lines) (viewers/webcomponents/htmx-security-secman/src/main/java/org/apache/causeway/viewer/webcomponents/htmx/security/secman/HtmxSecmanSecurityConfiguration.java)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Projects may be oversized for their cohesion
  • SignInPanelAbstract.onConfigure (cognitive 17) (viewers/wicket/ui/src/main/java/org/apache/causeway/viewer/wicket/ui/pages/login/SignInPanelAbstract.java)
  • XxxComment (viewers/wicket/viewer/src/main/java/org/apache/causeway/viewer/wicket/viewer/wicketapp/_CryptFactory.java)
  • XxxComment (viewers/wicket/viewer/src/test/java/org/apache/causeway/viewer/wicket/viewer/wicketapp/CryptFactoryTest.java)

New (92)

  • Ambiguous distinction between 'Append' and 'Replace'. While the names suggest different behaviors, in CSS manipulation contexts, 'Replace' often implies clearing existing classes first, whereas 'Append' adds. However, without clear documentation or consistent usage patterns in the API surface (e.g., no cssRemove), it's hard to distinguish intent from cssAppend vs cssReplace vs cssNormalize. Additionally, cssNormalize operates on a String, while others operate on Components, breaking the fluent component-chain pattern.
  • Change coupling: DataTableInternal.java ↔ CollectionModel.java (core/metamodel/src/main/java/org/apache/causeway/core/metamodel/tabular/internal/DataTableInternal.java)
  • Duplicated block (10 lines × 2) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (11 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (11–13 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (12 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (12–13 lines × 3) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (12–14 lines × 3) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (13 lines × 3) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (13–15 lines × 4) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (13–21 lines × 3) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (14 lines × 2) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (14 lines × 4) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (14–16 lines × 4) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (14–24 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (16 lines × 3) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (16–18 lines × 3) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (17 lines × 2) (extensions/core/commandlog/applib/src/main/java/org/apache/causeway/extensions/commandlog/applib/dom/CommandLogEntry.java)
  • Duplicated block (17 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • Duplicated block (30–32 lines × 2) (extensions/core/executionlog/applib/src/main/java/org/apache/causeway/extensions/executionlog/applib/dom/ExecutionLogEntry.java)
  • …and 72 more

Changes since last survey

  • 47 commits — 45 feature/other, 2 fixes

By area

  • (repo) — 12 commits
  • bom/pom.xml — 8 commits
  • antora/components — 5 commits
  • openspec/changes — 4 commits
  • viewers/webcomponents — 3 commits
  • commons/src — 2 commits
  • parent/pom.xml — 2 commits
  • viewers/graphql — 2 commits
  • viewers/wicket — 2 commits
  • (root) — 1 commit
  • .github/dependabot.yml — 1 commit
  • .github/workflows — 1 commit
  • api/applib — 1 commit
  • core/config — 1 commit
  • core/metamodel — 1 commit
  • regressiontests/tracing-compatibility — 1 commit

Notable commits

  • fix: CAUSEWAY-2297: fixes prev. commit
  • fix: Revert "Build(deps): bump cucumber.version from 7.34.8 to 8.0.4"
  • change: Build(deps): bump asm.version from 9.10.1 to 9.11
  • change: Build(deps): bump cucumber.version from 7.34.8 to 8.0.4
  • change: Build(deps): bump ognl:ognl from 3.4.14 to 3.4.16
  • change: Build(deps): bump org.codehaus.woodstox:stax2-api from 4.3.1 to 4.3.2
  • change: Build(deps): bump org.hibernate.validator:hibernate-validator
  • change: Build(deps): bump org.mvnpm:vega-lite from 6.4.3 to 6.5.0
  • change: Build(deps-dev): bump io.opentelemetry.contrib:opentelemetry-maven-extension
  • change: Build(deps-dev): bump io.opentelemetry.javaagent:opentelemetry-javaagent
  • change: Bumps Java baseline 17->21
  • change: Bumps maven surefire plugin 3.6.0-M1 -> 3.6.0
  • change: CAUSEWAY-2297: work on deprecations and warnings
  • change: CAUSEWAY-4054: [Wicket Viewer] Signin Remember Me Feature is now deprecated
  • change: CAUSEWAY-4054: adding mignotes
  • change: CAUSEWAY-4054: remove unused imports
  • change: CAUSEWAY-4058: archive current action invocation context
  • change: CAUSEWAY-4058: expose current action invocation context
  • change: CAUSEWAY-4058: propose current action invocation context
  • change: CAUSEWAY-4062: add semantic member span names
  • …and 27 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 9 added · 9 removed

Added dependency edges (9)

  • causeway-extensions-commandlog-persistence-jpa → causeway-extensions-commandlog-applib (coupling)
  • causeway-extensions-secman-integration → causeway-extensions-secman-applib (coupling)
  • causeway-extensions-secman-persistence-jpa → causeway-extensions-secman-applib (coupling)
  • causeway-extensions-sessionlog-persistence-jpa → causeway-applib (coupling)
  • causeway-testing-fixtures-applib → causeway-applib (coupling)
  • causeway-viewer-graphql-model → causeway-commons (coupling)
  • causeway-viewer-restfulobjects-rendering → causeway-viewer-restfulobjects-applib (coupling)
  • causeway-viewer-wicket-model → causeway-viewer-commons-model (coupling)
  • causeway-viewer-wicket-ui-test → causeway-core-metamodel (coupling)

Removed dependency edges (was a dependency, now gone) (9)

  • causeway-extensions-commandlog-persistence-jpa → causeway-extensions-commandlog-applib
  • causeway-extensions-secman-integration → causeway-extensions-secman-applib
  • causeway-extensions-secman-persistence-jpa → causeway-extensions-secman-applib
  • causeway-extensions-sessionlog-persistence-jpa → causeway-applib
  • causeway-testing-fixtures-applib → causeway-applib
  • causeway-viewer-graphql-model → causeway-commons
  • causeway-viewer-restfulobjects-rendering → causeway-viewer-restfulobjects-applib
  • causeway-viewer-wicket-model → causeway-viewer-commons-model
  • causeway-viewer-wicket-ui-test → causeway-core-metamodel

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

apache/causeway was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 22 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 5fc30b7dcb78e9f88dc7fbd9b533ce902e244dea — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.3+preprod-fddbc92cb8df.