---
title: August 2025
versions:
  cdsjs: 9.3.0+
  cdsdk: 9.3.0+
  cdsc: 6.3.0+
  cdsmtxs: 3.3.0+
  java: 4.3.0+
---

# August 2025

<ReleaseBadges />


[[toc]]


## New capire docs & samples

We consolidated all our samples repos together with the one for the capire docs in one GitHub org ⇒ one location for you and us to bookmark and find them all at:

- https://github.com/capire

Among many other advantages, the new org gives us the freedom to have individual repos for each sample, instead of monorepos only.

### Continuous Deployments

For example, this enables real continuous [deployments](https://github.com/capire/bookshop/deployments) of individual projects to staging and production environments using respective [GitHub Actions workflows](#github-actions).

![GitHub Deployments](../assets/capire-deployments.png) {style="zoom: 70%;"}

### GitHub Packages

It also allows us to use [GitHub Packages](https://github.com/orgs/capire/packages) for more realistic publishing and consuming reuse packages and reuse services.

![GitHub Packages](../assets/capire-packages.png)

Learn more about [*using GitHub Packages*](https://github.com/capire/xtravels?tab=readme-ov-file#using-github-packages) as well as [using local workspace setups](https://github.com/capire/xtravels?tab=readme-ov-file#using-workspaces) as an alternative in the readme of [*capire/xtravels*](https://github.com/capire/xtravels#readme). {.learn-more}



### GitHub Discussions

In addition, we also enabled [GitHub Discussions](https://github.com/orgs/capire/discussions) in there:

![GitHub Discussions switched on](../assets/capire-discussions.png)

> [!NOTE]
> Previous locations like https://github.com/sap-samples/cloud-cap-samples are now archived.





## New & General Available

### Fiori Draft Messages

CAP's generic support for persistent Fiori draft messages, which we rolled out as beta before, is now generally available (GA), with the following features:

- Fast feedback to end users through running validations on PATCH requests.
- Seamless editing through persisted validation errors.
- Better UX through combining custom validations and annotation-based ones.

Not supported yet:

- OData V2 UIs because they don't enforce _document URLs_.
- OData V4 UIs using SAP UI5 version < 1.135.0.

<video src="./assets/aug25/draft-validations_compressed.mp4" alt="Video demonstrating draft validations providing fast feedback to end users through validation on PATCH requests" autoplay loop muted webkit-playsinline playsinline style="border: 2px solid #AFACAB;" />

Try it out in our [SFlight sample app](https://github.com/capire/xtravels).

>  [!note]
>
>  Fiori draft messages require a database schema update.

You can disable this feature with <Config>cds.fiori.draft_messages:false</Config>.

[Learn more about **Draft Validations**.](/@external/guides/uis/fiori#validating-drafts){.learn-more}



### CAP MCP Server

The new MCP server for CAP provides AI-powered development assistance for your CAP applications.
It offers context-focused tools designed to help the AI agent better understand not only CAP APIs but also your specific project.

[`@cap-js/mcp-server`](https://github.com/cap-js/mcp-server)

Try it out to enhance your development workflow.




## CDS Language & Compiler

### Expressions in Annotations GA {#cxl}

CAP support for expressions as first-class annotation values is now **generally available** (GA).

Examples:

```cds
annotate Orders with @restrict: [
  { grant:'READ', where: ( buyer = $user.id ) }
];
```
```cds
annotate Foo with {
	bar @UI.Hidden: ( status != 'visible' );
}
```

[Learn more about **Expressions as Annotation Values**.](/@external/cds/cdl#expressions-as-annotation-values){ .learn-more}

Noteworthy:

- You must enclose annotation expressions in parentheses.
- The compiler checks the validity of the expression, including the path expressions.
- The compiler rewrites propagated expressions when elements are renamed in views.
- Expressions are translated to OData annotations wherever possible.

> [!note]
>
> While the compiler supports expression values generically for all annotations, the consumer of
> an annotation of course also needs to understand expressions. Currently this is the case for
> CAP's `@restrict` annotation (support for further CAP annotations is to be expected in upcoming releases)
> and for several SAP Fiori annotations.



### Optimized Path Expressions

A path expression that addresses the foreign key of a ***managed*** to-one association is always rewritten to select the local foreign key column, instead of reading the target's equally named primary key with a join.

For example, this query:

```sql
SELECT author.ID from Books
```

... was translated to the like of this **before**:

```sql
SELECT author.ID from Books
LEFT JOIN Authors ON Authors.ID = author_ID
```

... while it's always translated to this **now**:

```sql
SELECT author_ID from Books
```

This is the default behavior in the compiler and in the Node.js runtime. For Java, activate this behavior with the [<Config java>cds.sql.toOnePath.mode: optimize</Config>](/@external/java/developing-applications/properties#cds-sql-toonepath-mode) until it becomes the default.

> [!note]
>
> Both native SQL translations show identical behavior unless your data violates referential integrity. For example, if you had a foreign key without a matching target key, the new behavior returns the foreign key value, while the former one would have returned `NULL`.





### Auto-coerced Associations

A _managed_ to-one association at a value position in a query or expression is automatically coerced to its single foreign key.

For example, while this was required **before**:

```sql
SELECT from Books where author.ID = 150;
SELECT from Books where author.ID is not null;
```

This can be written **now** as:

```sql
SELECT from Books where author = 150;
SELECT from Books where author is not null;
```

This works for all places where path expressions can show up, such as views and projections, or [expressions in annotations](#cxl) in CDS sources, as well as runtime queries in Node.js.





## Node.js



### Search by `@Common.Text`

The runtime's generic handlers for `$search` requests now automatically include elements referred to by `@Common.Text` annotations by default. For example:

```cds
entity Books { //...
  @Common.Text : author.name
  author : Association to Authors;
}
```

[Learn more about searching data.](/@external/guides/services/served-ootb#searching-data){.learn-more}
[CAP Java supports this feature since April 2025.](apr25#enhanced-search){.learn-more}



### Streaming Query Results

Database services now let you stream query results for more efficient data handling. Instead of materializing the complete result set in memory, you can stream the result.

A raw stream can be obtained through [`SELECT.pipeline()`](/@external/node.js/cds-ql#pipeline) which, for example, can be piped directly to the HTTP response.

```js
await SELECT.from(Books) .pipeline (req.res)
```

If modification at runtime is required, an object stream can be obtained through [`SELECT.foreach()`](/@external/node.js/cds-ql#foreach) or through using `for await`.

```js
for await (let book of SELECT.from(Books)) { ... }
await SELECT.from(Books) .foreach (book => { ... })
```


[Learn more about querying data in CAP Node.js.](/@external/node.js/cds-ql#select){.learn-more}
[Try it out in our SFlight sample application.](https://github.com/capire/xtravels){.learn-more}



### `cds.requires` w/o `kind`

You can now configure remote services without specifying `kind`, for example:
::: code-group

```json [package.json]
{
  "cds": {
    "requires": {
      "SomeService": true
    }
  }
}
```
```yaml [.cdsrc.yaml]
cds:
  requires:
    SomeService: true
```
:::

Automatic protocol selection applies if a required service is configured without `kind` and the remote service supports multiple protocols. For example, if this service is declared like this, the best protocol is chosen automatically (`hcql` in this case):

```cds
@hcql @rest @odata service SomeService {...}
```

[Learn more about required services.](/@external/node.js/core-services#required-services){.learn-more}

### `cds.connect.to(<url>)`

Method [`cds.connect.to()`](/@external/node.js/cds-connect#cds-connect-to) now lets you connect to remote services with just an HTTP URL. For example, use that from [`cds repl`](/@external/tools/cds-cli#cds-repl) like that:
  ```js
  srv = await cds.connect.to ('http://localhost:4004/hcql/books')
  await srv.read `ID, title, author.name from Books`
  ```

The protocol is determined automatically based on occurrences of `hcql`, `rest`, or `odata` in the URL.

Note that the remote client has no model information about the remote service, so no type-specific transformations of sent queries are applied.

>  [!warning]
> This feature is **not to be used in production**! <br>
> It's meant as a handy convenience shortcut for design-time tasks only.



### `cds.linked(csn).collect()`

New method `collect()` has been added to [`LinkedCSN`](/@external/node.js/cds-reflect#linked-csn), which can be used to filter and pick out properties of definitions, like that:
  ```js
  const federated_entities = cds.linked(csn).collect (
    d => d.is_entity && d['@federated'],
    d => d.name
  )
  ```

### `cds.User.authInfo`

We introduced `cds.User.authInfo` as an optional generic container for authentication-related information.
For `@sap/xssec`-based authentication strategies, such as `ias`, `jwt`, and `xsuaa`, it's an instance of `@sap/xssec`'s [`SecurityContext`](https://www.npmjs.com/package/@sap/xssec#securitycontext). This replaces the former undocumented `cds.User.tokenInfo`, which is now deprecated.

[Learn more about authentication in CAP Node.js.](/@external/node.js/authentication){.learn-more}

> [!warning]
> The `cds.User.authInfo` property depends on your authentication library. CAP does not guarantee its content or existence. Use it with caution and always pin your dependencies as described in the best practices.





<span id="nodeucl" />



## Java

### Typed Query Results

You can now work more easily with query results using the generated [query builder interfaces](/@external/java/working-with-cql/query-api#concepts). For typed queries, the result is automatically typed with the corresponding [data accessor interface](/@external/java/cds-data#typed-access). You no longer need to provide the accessor interface when calling `single()`, and you can use `list()` and `stream()` to replace `listOf()` and `streamOf()`:

```java
import static cds.gen.catalogservice.CatalogService_.BOOKS;

@Autowired
CatalogService service;

var select = Select.from(BOOKS).byId(4711);
Books book = service.run(select).single();
String title = book.getTitle();
```

To enable this feature, generate [query builder interfaces](/@external/java/working-with-cql/query-api#concepts) with the `linkedInterfaces` option:

::: code-group
```xml [srv/pom.xml]
<execution>
  <id>cds.generate</id>
  <goals>
    <goal>generate</goal>
  </goals>
  <configuration>
    <!-- ... -->
    <linkedInterfaces>true</linkedInterfaces>
  </configuration>
</execution>
```
:::

If you encounter compile errors, update your `Result` declarations to use `CdsResult<TYPE>`:

```java
var select = Select.from(BOOKS).byId(4711);
Result result = service.run(select); // [!code --]
Books book = result.single(Books.class); // [!code --]
CdsResult<Books> result = service.run(select); // [!code ++]
Books book = result.single(); // [!code ++]
```

For generic results, assign to an untyped query by using `CqnSelect`:

```java
CqnSelect select = Select.from(BOOKS).byId(4711);
Result result = dataStore.execute(select);
Row book = result.single();
```

::: tip
`Result` now extends `CdsResult<Row>`. All methods in `Result` are also available in `CdsResult`.
:::

::: warning
We've added new `run` method overloads to the `CqnService` interface. If you use Mockito to mock `run` methods in your tests and rely on argument matchers for `Select` or `Update` (for example, `any(Select.class)`) instead of `CqnSelect` or `CqnUpdate`, you may run into incompatibilities in tests. Similarly, not parameterized `Select` or `Update` declarations can cause compile-time errors.

To simplify migration, use the OpenRewrite recipe to update argument matchers and parameterize untyped `Select` or `Update` declarations with `?`:

```sh
mvn org.openrewrite.maven:rewrite-maven-plugin:run \
  -Drewrite.recipeArtifactCoordinates=com.sap.cds:cds-services-recipes:4.3.0 \
  -Drewrite.activeRecipes=com.sap.cds.services.migrations.MigrateStatements \
  -DskipMavenParsing=true
```
:::

### Attachments in Object Store <Alpha/>

Version `1.2.0` of `cds-feature-attachments` now supports [SAP BTP Object Store](https://discovery-center.cloud.sap/serviceCatalog/object-store).

When activated, attachments are stored in an Object Store instance instead of the default persistence.
Add `cds-feature-attachments-oss` as Maven dependency in your `srv/pom.xml` to use this feature:

```xml
<dependency>
    <groupId>com.sap.cds</groupId>
    <artifactId>cds-feature-attachments-oss</artifactId>
    <version>${latest-version}</version>
</dependency>
```

A valid Object Store service binding created for one of the supported backends is required:
- AWS S3
- Azure Blob Storage
- Google Cloud Storage

::: tip No support for multitenancy
The Object Store integration does only support single-tenant applications.
:::

[Learn more about Object Store integration.](https://github.com/cap-java/cds-feature-attachments/tree/main/storage-targets/cds-feature-attachments-oss){.learn-more}

### Code Generator Documentation

To benefit from compile-time code checks, it's highly recommended to use type-safe APIs when working with CDS data in custom Java handlers.
The goal `cds:generate` of the CDS Maven plugin automatically generates [accessor interfaces](/@external/java/cds-data#typed-access) for all structured CDS model types.
This generator has evolved over time and offers a comprehensive feature set to control the resulting Java interfaces. Here are some example how you can use it:

- Influence the Java package names.
- Filter entities that are subject to code generation.
- Influence the style of the interfaces.
- Influence the name of the fields and methods.
- Influence API documentation of a package.

[Find here detailed documentation about the code generator.](/@external/java/developing-applications/building#codegen-config){.learn-more}

### Link to Index Page

When running CAP Java locally (development mode), the console now shows a clickable link to the index page for easy access.

<video src="./assets/aug25/java-index-link_compressed.mp4" alt="Video showing clickable link to CAP Java index page displayed in console for easy local access" autoplay loop muted webkit-playsinline playsinline style="border: 2px solid #AFACAB" />


## Tools


### IntelliJ Community Support

Version 2.0.0 of the [CDS IntelliJ Plugin](https://plugins.jetbrains.com/plugin/25209-sap-cds-language-support) marks a significant milestone – the plugin is now fully compatible with the free IntelliJ IDEA Community Edition, making CDS development accessible to all developers without requiring a paid license.

![CDS editing support in IntelliJ](assets/aug25/ij-2.0.0-editing-support-examples.png)

#### Comprehensive IDE Features

The plugin now supports a full range of IDE capabilities including:
- **Navigation**: _Go to Definition_, _Go to Implementation_, _Find References_, _Document Links_
- **Code Intelligence**: Hover documentation, workspace symbols, document highlights, structure tool window
- **Code Quality**: Range/Document formatting, quick fixes for diagnostics

#### Enhanced LSP Integration

The plugin leverages the _LSP4IJ_ plugin for improved language server integration, providing more reliable and performant IDE features. _LSP4IJ_ is automatically installed as a dependency when you install the CDS plugin.

#### Configuration & Settings

The new settings page allows you to configure the CDS language server under *Languages & Frameworks > CDS*:

![CDS language server user settings page in IntelliJ](assets/aug25/ij-lsp-user-settings.png){width=80%}

Additional improvements include automatic Node.js interpreter detection and an `.http` file conversion _intention_ for better compatibility with IntelliJ.



### ESLint Checks for JavaScript

We have added lint checks for JavaScript service implementations.

As an example, one of the checks can find wrongly used `SELECT` clauses that can lead to [SQL injection](/@external/node.js/cds-ql#avoiding-sql-injection) issues:
```js
SELECT`ID`.from `Authors`.where(`name = ${name}`) // [!code --] bad, ${name} is not validated
SELECT`ID`.from `Authors`.where `name = ${name}`  // [!code ++] OK, ${name} is validated
```

Enable all JS checks in your ESLint configuration like so:
```js
import cdslint from '@sap/eslint-plugin-cds'
export default [ ..., cdslint.configs.js.all ]
```

[See the full list of checks.](/@external/tools/cds-lint/rules/#javascript){.learn-more}



## GitHub Actions Guides & Samples {#github-actions}

We have added a new end-to-end guide on how to set up GitHub actions with recommended defaults.

[Read the new guide.](/@external/guides/deploy/cicd#github-actions){.learn-more}

In addition, the new [capire/samples](https://github.com/capire/samples) repository provides simple example workflows to [test, deploy, and release new versions](https://github.com/capire/samples/tree/main/.github/workflows).