--- title: September 2025 versions: cdsjs: 9.4.0+ cdsdk: 9.4.0+ cdsc: 6.4.0+ cdsmtxs: 3.4.0+ java: 4.4.0+ --- # September 2025 [[toc]] ## Node.js {#cds-js} ### Translated Error Messages CAP Node.js now provides default translations for annotation-based validation errors in all CAP-supported languages. This enhancement allows the runtime to send more user-friendly message texts to the UI, streamlining the user experience for all CAP applications. As part of this update, we streamlined the error codes, renaming `ASSERT_NOT_NULL` to `ASSERT_MANDATORY` to better reflect its purpose. For custom translations, use the previous error code `ASSERT_NOT_NULL`. Additionally, use the compatibility flag cds.features.compat_assert_not_null:true to restore compatibility until the next major version. :::warning Impact on Tests If your application's unit tests contain assertions about message texts, please update them to use error codes instead. ::: [Learn more about error handling in Node.js.](/@external/node.js/events#req-reject){.learn-more} [Learn more about internationalization in Node.js.](/@external/node.js/cds-i18n){.learn-more} ### Simplified Support for Streaming The new QL API [`SELECT ... .stream ()`](/@external/node.js/cds-ql#stream) returns the data from the database as a raw stream. See the following snippet in the context of our new [`@capire/xtravels`](https://github.com/capire/xtravels) sample: ```js this.on ('exportJSON', async req => { let query = cds.ql (TravelsExport.query) let stream = await query.localized.stream() return req.reply (stream, { filename: 'Travels.json' }) }) ``` ### Revised Fiori Support We have revised the implementation and documentation of our support for Fiori, specifically in the area of handler registration. The documentation now takes a use-case-based approach, enabling you to more quickly identify the hook you need to implement. In summary, you can register handlers for the following draft-specific events: ```js srv.on('NEW', MyEntity.drafts, /*...*/) srv.on('PATCH', MyEntity.drafts, /*...*/) srv.on('SAVE', MyEntity.drafts, /*...*/) srv.on('EDIT', MyEntity, /*...*/) srv.on('DISCARD', MyEntity.drafts, /*...*/) ``` [Learn more about serving Fiori UIs.](/@external/node.js/fiori){.learn-more} ### Combined Input Validation Annotation-based input validation now runs together with custom validations executed in the `before` phase, so end users experience a single validation step. Previously, custom validations ran only after annotation-based validation passed successfully. If the `@mandatory` annotation is violated, the input is still rejected immediately because type safety cannot be guaranteed. ::: warning If your validation depends on the input already being validated, for example, a string's format or a number's range, use an `on` handler to run your logic and then delegate to the generic handler via the `next` parameter. ::: [Learn more about annotation-based input validation.](/@external/guides/services/constraints){.learn-more} [Learn more about registering `on` handlers.](/@external/node.js/core-services#srv-on-request){.learn-more} ## Java {#cds-java} ### JDK 25 Compliance CAP Java is successfully tested with the brand new [JDK 25](https://openjdk.org/projects/jdk/25/) which is an LTS version. We recommend configuring [SapMachine](https://sap.github.io/SapMachine/) 25 JDK (respective JRE) with the [SAP Java buildpack](https://help.sap.com/docs/btp/sap-business-technology-platform/developing-java-in-cloud-foundry-environment) as shown in the example (`mta.yaml`): ```yaml [mta.yaml] modules: - name: MyCAPJavaApp type: java path: srv parameters: ... buildpack: sap_java_buildpack_jakarta properties: JBP_CONFIG_COMPONENTS: "jres: ['com.sap.xs.java.buildpack.jre.SAPMachineJRE']" JBP_CONFIG_SAP_MACHINE_JRE: '{ version: 25.+, use_offline_repository: false }' ``` Current `sap_java_buildpack_jakarta` does not yet officially support JDK 25 and therefore has some limitations: - Public Internet access is required to download the JDK (no offline mode). - Only Java Main deliveries are supported (no restriction for Spring Boot apps). Some highlights of the new JVM: - [Scoped values](https://openjdk.org/jeps/506) to safely share data within the methods calls in the same thread without resorting to method parameters. - [Flexible Constructor Bodies](https://openjdk.org/jeps/513) allow to write constructors in a more streamlined way. - [Compact Object Headers](https://openjdk.org/jeps/519) show 22% less heap space in SPECjbb2015 benchmark and JSON parser benchmark runs in 10% less time. #### cds-services-archetype The `cds-services-archetype` supports the creation of new CAP Java projects with JDK 25 as target runtime. This can be achieved with the command line option `-DjdkVersion=25`. ::: warning Currently create new projects with JDK 17 or 21 There is currently an issue with the official [`maven-archetype-plugin`](https://maven.apache.org/archetype/maven-archetype-plugin) itself, it doesn't work with JDK 25. Therefore, you need to use JDK 17 or 21 to create a CAP Java project. After the creation you have to switch the JDK to 25 as target runtime to build and run the newly created CAP Java project. ::: ### Aggregating over Associations You can now aggregate values of associated entities directly in your CQL queries by using the aggregation methods `min`, `max`, `sum`, and `count` on associations with to-many relationships. Example: ```java Select.from(ORDERS).columns( o -> o.orderNo(), o -> o.date(), o -> o.items().sum(i -> i.amount()).as("total")); ``` This query selects `orderNo` and `date` from Orders and additionally sums up the amounts of the associated items, which it returns as "total". [Learn more about Aggregating over Associations.](/@external/java/working-with-cql/query-api#aggregating-associations){.learn-more} ### Streamlined CDS Models from Maven Dependencies So far, CDS models imported from Maven dependencies were only available in the scope of the Maven module that declared the dependency to the reuse package. This prevented, for example, CDS files in the `db` directory from accessing models from dependencies defined in the `srv` module. Now CDS models from reuse packages are available to the whole CAP project by default. They resolve to `target/cds` instead of `srv/target/cds`. This ensures that you can consistently import them from all CDS files in the project using proper `using` declarations. ::: warning If you have declared `using` statements, leveraging file paths like `using '../srv/target/cds//'`, make sure to switch to the correct syntax `using '/'`. ::: If you need to resolve reuse modules only within the scope of the declaring module, you can opt out of this new behavior. Configure the `to` property of the `resolve` goal: ```xml com.sap.cds cds-maven-plugin ${cds.services.version} ... cds.resolve resolve ${project.build.directory} ... ``` ### Miscellaneous #### Streamlined Ordering of Security Configs Spring Security configurations provided by CAP Java now correctly use the `@Order` annotation by placing it on the `SecurityFilterChain` bean method instead of the `Configuration` class: ```java @Configuration @EnableWebSecurity public class ActuatorSecurityConfig { @Bean @Order(1) // [!code focus] public SecurityFilterChain appSecurityConfig(HttpSecurity http) { // ... } } ``` Using a proper `@Order` makes it easier for you to configure custom security configurations that the system evaluates with the correct precedence. ::: warning As this was wrongly done in all our samples, documentation and framework code, please double-check any custom security configurations you have defined for the same mistake. ::: #### Setting Application UI URL Programmatically Until now, configuration defined the *application UI URL* that the system returns upon a new tenant subscription. Now, however, you can programmatically override the returned default *application UI URL* by implementing an `On` handler for the `APP_UI_URL` event of the `DeploymentService`. The `AppUiUrlEventContext` interface encapsulates that event and gives you access to the `tenant`, `subdomain` and subscription `options` from the *SaaS registry* or *Subscription Manager* callback. You can use these to define the *application UI URL* you want to return to the subscriber as shown in the following example: ```java @ServiceName(DeploymentService.DEFAULT_NAME) public class MyCustomDeploymentServiceHandler implements EventHandler { @On public String onAppUiUrl(AppUiUrlEventContext context) { String tenant = context.getTenant(); // the tenant id String subdomain = context.getSubdomain(); // the subdomain Map options = context.getOptions(); // the subscription options return "https://" + tenant + "." + subdomain + "/" + options.get("subscriptionAppPlan"); } } ``` #### Disable Draft Garbage Collection for Entity The new annotation `@odata.draft.gc: false` can be used to disable the Draft Garbage Collection for a particular entity. ```cds @odata.draft.gc: false entity DraftEnabled { ... } ``` [Learn more about garbage collection for Drafts.](/@external/java/fiori-drafts#draft-gc){.learn-more} #### Simplified Bound Action Calls in OData For convenience, the CAP Java runtime now allows to call bound actions/functions without prefixing them with the service name. #### Performance The CAP Java runtime now optimizes statement normalization to improve efficiency and reduce resource consumption. ## Tools {#tools} ### Important Changes ❗️ { .important #important-changes-in-tools} #### `Edm.String` now Becomes CDS `String` in `cds import` `cds import` for EDMX files now maps `Edm.String` fields without length restriction to CDS's `String` (instead of `LargeString` as before). If you reimport and redeploy OData APIs, this leads to database type changes with [default lengths](/@external/cds/cdl#built-in-types). Make sure this still fits your data. In case of issues, change the type length or use `LargeString` again. ### `cds add app-frontend` The new [SAP BTP Application Frontend](https://help.sap.com/docs/application-frontend-service) service is now easy to integrate: ```sh cds add app-frontend ``` > **Note**: Support for the service is currently limited to single-tenant applications. As the successor to the SAP BTP HTML5 Application Repository, it offers new features such as built-in versioning and delivers a simpler, more streamlined development experience for frontend applications. [Read the blog post: “Introducing Application Frontend Service”](https://community.sap.com/t5/technology-blog-posts-by-sap/introducing-application-frontend-service/ba-p/14091408){.learn-more} [Read the blog post about the `afctl` tool.](https://community.sap.com/t5/technology-blog-posts-by-sap/simple-ui-applications-with-application-frontend-service/ba-p/14096009){.learn-more} ### Annotations with Better Editor Support The editor enhances code completion and diagnostics for annotating annotation values to follow [the latest guidelines](/@external/guides/protocols/odata#annotating-annotations). Here's a quick overview of the enhancements: - Offers suggestions for annotations using shortcut syntax in code completion lists (previously only record properties were provided). ![annotating annotations with code completion](../assets/annotating_annotations_cc.png){style="box-shadow: 1px 1px 5px #888888; width:600px;"} - No more suggestions with deprecated `$value` syntax in code completion lists. - Diagnostics now show warning messages for the deprecated `$value` syntax. ![diagnostics for annotating annotations](../assets/annotating_annotations_diagnostics.png){style="box-shadow: 1px 1px 5px #888888; width:600px;"} ## SAP Integration Suite, Advanced Event Mesh GA [SAP Integration Suite, advanced event mesh](https://www.sap.com/products/technology-platform/integration-suite/advanced-event-mesh.html) enables applications to engage in real-time asynchronous communication across distributed environments using a fully managed cloud service designed for event-driven architectures. After a successful test and evaluation phase, both open-source plugins, [`@cap-js/advanced-event-mesh`](https://github.com/cap-js/advanced-event-mesh) and [`com.sap.cds:cds-feature-advanced-event-mesh`](https://github.com/cap-java/cds-feature-advanced-event-mesh), are now **generally available** (GA). The most notable addition is the support for cross-subaccount broker validation. [Find more details in the Plugins page entry.](/@external/plugins/index#advanced-event-mesh){.learn-more} ## capire Updates ### Java CQL Query API Enhancements New `concat` function usage documentation for building more complex string concatenation operations in Java CQL queries, improving query composition capabilities. [Learn more about Java CQL Query API.](/@external/java/working-with-cql/query-api#string-expressions){.learn-more} ### Java Security Configuration Improvements Updated security configuration patterns with better guidance for custom Spring Security setups and improved IAS authentication flows documentation. [Learn more about Java security.](/@external/java/security#custom-spring-security-config){.learn-more} ### Outbox Pattern with Shared Database New documentation on implementing outbox pattern workarounds when using shared databases, providing solutions for distributed transaction challenges. [Learn more about Java event queues with shared databases.](/@external/java/event-queues#shared-databases){.learn-more} ### Extensibility and Composition Improvements Enhanced Maven dependency resolution for CDS models, making reuse packages globally available across project modules and improving extensibility patterns. [Learn more about extensibility and composition.](/@external/guides/integration/reuse-and-compose#importing-from-maven-dependencies){.learn-more} ### ...and more - [Improved multitenancy documentation with better deployment hints.](/@external/guides/multitenancy/index) - [Enhanced error handling documentation with security warnings.](/@external/node.js/events) - [Updated Spring Boot integration samples and configurations.](/@external/java/spring-boot-integration) - [Fixed Node.js database connection pool configuration documentation.](/@external/node.js/databases) - [Improved cds.error() API documentation with HTTP status codes.](/@external/node.js/cds-facade#cds-error) - [Updated Java properties configuration examples.](/@external/java/developing-applications/properties) - [Enhanced Cloud Foundry deployment documentation.](/@external/guides/deploy/to-cf) - [Updated about section with AI-related content.](/@external/get-started/features.md#what-about-ai)