@sap/cds-dk 10.0.5 → 10.0.7

package/CHANGELOG.md

@@ -6,10 +6,38 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## Version 10.0.7 - 2026-08-07
+
+### Fixed
+
+- Bundle `@sap/cds-mtxs` 4 again, instead of 3.
+- `cds import --from asyncapi` now correctly imports types referenced via `$ref` in AsyncAPI schemas, including `allOf` composition, and no longer loses types from earlier events when a service has multiple events.
+- `cds add html5-repo`, `cds add workzone`, and `cds add portal` no longer emit an HTML5 application content deployer module into `mta.yaml` when the project has no UI apps, avoiding the `could not find the ".../gen/app" path` build failure.
+- `cds init --nodejs` creates the ESLint and VS Code config files again
+
+### Changed
+
+- `cds init --nodejs` creates a cleaned-up .gitignore file
+
+## Version 10.0.6 - 2026-07-24
+
+### Added
+
+- `cds add xsuaa` now generates namespace-suffixed XSUAA `role-collections` for Kyma.
+
+### Fixed
+
+- `cds add http` no longer throws `MULTIPLE_DOCS` when `application.yaml` uses `---` separators (Spring Boot multi-profile format).
+- `cds export --data` now reads seed data via in-memory SQLite instead of the configured db driver, so it no longer fails in projects with `requires.db: hana` (e.g. CAP Java).
+- `cds init --java --add mta` now writes `path: srv` for the Java `srv` module in `mta.yaml` instead of `gen/srv`, so `mbt build` no longer fails with `the "gen/srv" path of the "<app>-srv" module does not exist`.
+- `cds version` no longer reports dependency problems if no dependencies are installed at all. It prints an info message instead.
+- `cds add test` creates tests that are green by default. Sample data is provided as commented code.
+
 ## Version 10.0.5 - 2026-07-16
 
 ### Fixed
 
+- `cds build --for hana` now declares the plugin for native HANA artifacts placed in the build output (e.g. a `.hdbprojectionview` from `db/src`) in the generated `.hdiconfig`.
 - `cds add typer` now generates a `jsconfig.json` file that works with VS Code.
 - `cds debug <app> --force` on Kyma now preserves existing `NODE_OPTIONS` flags (e.g. `--max-old-space-size`) instead of overwriting them when enabling the inspector.
 - `cds add sample` now selects `stock` in the Books list and object pages, so the overstock discount shows up in the UI.

package/bin/export.js

@@ -200,7 +200,7 @@ class Export extends Minify {
   }
 
   async export_data (model) {
-    const db = cds.db = await cds.deploy ('*',{silent:true})
+    const db = cds.db = await cds.deploy ('*',{silent:true}).to ('sqlite::memory:')
     const out = path.resolve (this.options.to, 'data')
     await fs.promises.rm (out, { recursive: true, force: true })
     await mkdirp (this.options.to, 'data')

package/bin/version.js

@@ -1,3 +1,4 @@
+const cds = require('../lib')
 
 module.exports = exports = async function cds_version (pattern, options) {
   console.log()
@@ -9,7 +10,12 @@ module.exports = exports = async function cds_version (pattern, options) {
   print_versions (all.flat(),o)
   if (!o.json) {
     if (o.info) console.log ('\n','> Project:', project_info (o))
-    if (o._elsp) console.log ('\n', `${RED}ELSPROBLEMS${RESET} reported by ${BOLD}npm ls${RESET}. Run ${BOLD}npm install${RESET} to fix dependency problems, then rerun ${BOLD}cds version${RESET}.`)
+    if (o._elsp) {
+      if (!cds.utils.fs.existsSync(join(o.root, 'node_modules')))
+        console.log (`\nNo dependencies installed. Run ${BOLD}npm install${RESET}, then rerun ${BOLD}cds version${RESET}.`)
+      else
+        console.log (`\n${RED}ELSPROBLEMS${RESET} reported by ${BOLD}npm ls${RESET}. Run ${BOLD}npm install${RESET} to fix dependency problems, then rerun ${BOLD}cds version${RESET}.`)
+    }
   }
   console.log()
 }
@@ -49,8 +55,6 @@ exports.help = `
       repository URL at the end as a markdown link.
 `
 
-
-const cds = require('../lib')
 const $ = cds.utils.sh || sh_polyfill
 const child_process = require('node:child_process')
 const home = require('os').homedir()

package/lib/build/plugins/hana/index.js

@@ -68,7 +68,6 @@ module.exports = class HanaBuildPlugin extends require('../internal') {
             }
 
             // create additional stuff in dest
-            await this._writeHdiConfig(hdiPlugins)
             await this._writeHdiNamespace()
             await this._writeUndeployJson()
 
@@ -100,6 +99,8 @@ module.exports = class HanaBuildPlugin extends require('../internal') {
                 )
             }
 
+            await this._writeHdiConfig(hdiPlugins)
+
             // relocate .hdbsynonymconfig files containing *.configure properties to cfg/ folder
             // HDI's template mechanism for configuration files only works from the cfg/ folder
             // For inplace builds (Java), restrict the scan to compileDest only to avoid moving user's
@@ -433,7 +434,8 @@ module.exports = class HanaBuildPlugin extends require('../internal') {
     async _writeHdiConfig(compileHdiPlugins) {
         const DEFAULT_HDI_PLUGINS = [FILE_EXT_CSV, FILE_EXT_HDBTABLEDATA, FILE_EXT_HDBTABLE, ".hdbview", ".hdbindex", ".hdbconstraint", ".hdbcalculationview"]
         const undeployHdiPlugins = await this._readTypesFromUndeployJson() // see CAP issue #6222
-        const hdiPlugins = new Set([...DEFAULT_HDI_PLUGINS, ...undeployHdiPlugins, ...compileHdiPlugins])
+        const destHdiPlugins = await this._readTypesFromCompileDest()
+        const hdiPlugins = new Set([...DEFAULT_HDI_PLUGINS, ...undeployHdiPlugins, ...compileHdiPlugins, ...destHdiPlugins])
         let hdiConfigPath
 
         // do not create the .hdiconfig file in 'gen/db' root folder for now
@@ -543,6 +545,21 @@ module.exports = class HanaBuildPlugin extends require('../internal') {
         return hdiPlugins
     }
 
+    async _readTypesFromCompileDest() {
+        const hdiPlugins = new Set()
+        const dir = path.join(this.task.dest, 'src')
+        if (!exists(dir)) return hdiPlugins
+
+        const template = await _readTemplateAsJson('.hdiconfig-all')
+        const knownSuffixes = new Set(Object.keys(template['file_suffixes']).map(key => '.' + key))
+        const files = await find(dir, { filter: (entry) => !isdir(entry) })
+        files.forEach(file => {
+            const suffix = path.extname(file)
+            if (knownSuffixes.has(suffix)) hdiPlugins.add(suffix)
+        })
+        return hdiPlugins
+    }
+
     async _validateMigrationTableFiles() {
         const dbSrcDir = path.join(this.task.src, "src")
         const migrationTableFiles = await find(dbSrcDir, { filter: (res) => {

package/lib/import/asyncapi/parserContext.js

@@ -1,18 +1,33 @@
 const { getRegExpGroups } = require('./utils');
 const messages = require("../message").getMessages();
 
+/**
+ * @typedef {{ type?: string|string[], format?: string, properties?: Record<string, AsyncApiSchema>, items?: AsyncApiSchema, allOf?: AsyncApiSchema[], '$ref'?: string, required?: string[], additionalProperties?: boolean|AsyncApiSchema, enum?: Array<*>, default?: *, nullable?: boolean, [key: string]: * }} AsyncApiSchema
+ * @typedef {{ components: { messages: Record<string, AsyncApiMessage>, schemas: Record<string, AsyncApiSchema> }, info?: object, [key: string]: * }} AsyncApiDocument
+ * @typedef {{ name: string, payload?: AsyncApiSchema, [key: string]: * }} AsyncApiMessage
+ * @typedef {{ type?: string|{'ref':string[]}, kind?: string, elements?: Record<string, CsnElement>, items?: CsnElement, '@cds.external'?: string, '@mandatory'?: boolean, precision?: number, scale?: number, default?: *, enum?: object, [key: string]: * }} CsnElement
+ * @typedef {Record<string, *>} Annotations
+ * @typedef {Record<string, CsnElement | null>} CsnTypeMap
+ */
+
 module.exports = class ParserContext {
     /**
-     * @constructor
+     * @param {AsyncApiDocument} content
      */
     constructor(content) {
         this.services = this.getServicesFromContent(content);
     }
 
+    /**
+     * @param {string} eventName
+     */
     getTopicName(eventName) {
         return eventName.startsWith('ce/') ? eventName.substring(3) : eventName;
     }
 
+    /**
+     * @param {string} messageRefString
+     */
     getEventName(messageRefString) {
         const lastSlashIndex = messageRefString.lastIndexOf('/');
         return lastSlashIndex == -1 ? '' : messageRefString.substring(lastSlashIndex + 1);
@@ -20,9 +35,10 @@ module.exports = class ParserContext {
 
     /**
      * Returns services from the asyncapi json object along with the events and annotations.
-     * @returns an object with all the services.
+     * @param {AsyncApiDocument} content - root AsyncAPI document
      */
     getServicesFromContent(content) {
+        /** @type {Record<string, *>} */
         const services = {};
         const serviceAnnotations = this.getServiceAnnotations(content);
 
@@ -49,15 +65,17 @@ module.exports = class ParserContext {
 
             // add topic annotation
             eventAnnotations['@topic'] = this.getTopicName(eventName);
+            /** @type {Record<string, CsnElement>} */
             let properties = {};
+            /** @type {CsnTypeMap} */
             let types = {};
 
             if (value.payload) {
                 // gets the schema being referred to in the event
                 const eventSchema = this.resolveRef(content, value.payload);
-                [properties, types] = this.getPropertiesAndTypes(event, eventSchema);
+                [properties, types] = this.getPropertiesAndTypes(event, eventSchema, content);
             }
-            services[service].types = types;
+            services[service].types = { ...services[service].types, ...types };
             services[service].events[event] = { 'kind': 'event', '@cds.external': 'true', ...eventAnnotations, elements: properties };
         });
 
@@ -66,7 +84,7 @@ module.exports = class ParserContext {
 
     /**
      * Returns annotations of a particular service.
-     * @returns an object with all the annotations as key value pairs.
+     * @param {AsyncApiDocument} content - root AsyncAPI document
      */
     getServiceAnnotations(content) {
         const serviceAnnotationsMapping = {
@@ -84,9 +102,10 @@ module.exports = class ParserContext {
 
         if (content.info) {
             for (const [key, value] of Object.entries(infoAnnotationsMapping)) {
-                if (content.info[key] && !(content.info[key] instanceof Object)) {
+                /** @type {Record<string, *>} */ const info = content.info;
+                if (info[key] && !(info[key] instanceof Object)) {
                     // info values will always be in string format
-                    annotations['@AsyncAPI.' + value] = content.info[key];
+                    annotations['@AsyncAPI.' + value] = info[key];
                 }
             }
         }
@@ -95,8 +114,8 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns annotations of a particular event. Here the parameter content is event content.
-     * @returns an object with all the annotations as key value pairs.
+     * Returns annotations of a particular event.
+     * @param {AsyncApiMessage} content - message object from components.messages
      */
     getEventAnnotations(content) {
         const eventLevelAnnotationsMapping = {
@@ -114,9 +133,8 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns validity of the annotation value. Here the parameter
-     * content is the annotation name and value of the annotation.
-     * @returns true/false depending on the annotation value.
+     * @param {string} annotation - annotation name (without @AsyncAPI. prefix)
+     * @param {*} value
      */
     isValidAnnotationValue(annotation, value) {
         const objectTypeAnnotations = ['StateInfo', 'EventSourceParams', 'EventCharacteristics', 'EventStateInfo'];
@@ -134,11 +152,12 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns annotations for an event/service. Here the parameter content
-     * is event/service content along with the corresponding mapping.
-     * @returns an object with the annotations as key value pairs.
+     * Returns annotations for an event/service.
+     * @param {object} content - event or service object
+     * @param {Record<string, string>} annotationsMapping - map of AsyncAPI extension key to CDS annotation suffix
      */
     getAnnotations(content, annotationsMapping) {
+        /** @type {Annotations} */
         const annotations = {};
 
         for (const [key, value] of Object.entries(content)) {
@@ -160,11 +179,33 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns the referred schema. Here the content is the asyncapi
-     * document and payloadObject is the reference path
-     * @returns an object with the referred schema.
+     * Merges allOf entries into a single schema object with combined properties.
+     * Resolves any $ref entries within the allOf array using the provided document.
+     * @param {AsyncApiSchema} schema - AsyncAPI schema object, possibly containing allOf
+     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
+     */
+    flattenAllOf(schema, docContent) {
+        if (!schema.allOf) return schema;
+        /** @type {AsyncApiSchema} */
+        const merged = { type: 'object', properties: {} };
+        const required = [];
+        for (const entry of schema.allOf) {
+            const resolved = entry['$ref'] ? this.resolveRef(docContent, entry) : entry;
+            const flat = this.flattenAllOf(resolved, docContent);
+            Object.assign(merged.properties ?? {}, flat.properties || {});
+            if (flat.required) required.push(...flat.required);
+        }
+        if (required.length) merged.required = required;
+        return merged;
+    }
+
+    /**
+     * Returns the referred schema.
+     * @param {AsyncApiDocument} content - root AsyncAPI document
+     * @param {AsyncApiSchema | {'$ref': string}} payloadObject - either a $ref object or an inline schema
      */
     resolveRef(content, payloadObject) {
+        /** @type {AsyncApiSchema} */
         let schema = {};
 
         if (payloadObject['$ref']) {
@@ -190,40 +231,46 @@ module.exports = class ParserContext {
 
     /**
      * Returns the properties and types generated, related to an event.
-     * @returns a properties object and a types object.
+     * @param {string} eventName
+     * @param {AsyncApiSchema} content - resolved AsyncAPI schema object for the event payload
+     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
+     * @returns {[Record<string, CsnElement>, CsnTypeMap]}
      */
-    getPropertiesAndTypes(eventName, content) {
+    getPropertiesAndTypes(eventName, content, docContent) {
+        /** @type {Record<string, CsnElement>} */
         const properties = {};
-        let types = {};
+        /** @type {CsnTypeMap} */
+        const types = {};
 
         if (content.properties) {
             for (const [key, value] of Object.entries(content.properties)) {
-                // will contain type objects generated for a property
-                let referredTypes = {};
                 let isRequired = false;
                 if (content['required']?.includes(key)) isRequired = true;
-                [properties[key], referredTypes] = this.parseProperty(eventName, key, value, isRequired);
-                // collecting all the types
-                types = { ...types, ...referredTypes };
+                properties[key] = this.parseProperty(eventName, key, value, isRequired, docContent, types);
             }
         }
         return [properties, types];
     }
 
     /**
-     * Returns the processed objects for property and type.
-     * @returns property object and type object.
+     * Returns the processed CSN element object for a property.
+     * @param {string} eventName
+     * @param {string} propertyName
+     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
+     * @param {boolean} isRequired
+     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
+     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
      */
-    parseProperty(eventName, propertyName, propertyContent, isRequired) {
+    parseProperty(eventName, propertyName, propertyContent, isRequired, docContent, types) {
         let property = {};
         let propertyAttributes = {};
-        let types = {};
 
         if (isRequired === true) {
             property['@mandatory'] = true;
         }
 
         let type = this.getTypeFromArray(propertyContent.type);
+        if (!type && propertyContent.allOf) type = 'object';
 
         // case where type is defined
         if (type && (type === 'object' || type === 'array')) {
@@ -231,48 +278,55 @@ module.exports = class ParserContext {
             propertyName = propertyName[0].toUpperCase() + propertyName.substring(1);
             let typeName = eventName + "." + propertyName;
             // generate object for the introduced type
-            const elements = this.getTypeElements(propertyContent);
+            const elements = this.getTypeElements(propertyContent, docContent, types);
             types[typeName] = { 'kind': 'type', '@cds.external': 'true', ...elements };
             // referring to the generated type from the property
             propertyAttributes = { 'type': typeName };
         } else {
-            propertyAttributes = this.getPropertyObject(propertyContent);
+            propertyAttributes = this.getPropertyObject(propertyContent, docContent, types);
         }
         property = { ...property, ...propertyAttributes };
 
-        return [property, types];
+        return property;
     }
 
     /**
-     * Returns generated type for the property.
-     * @returns an object for a type.
+     * Returns the CSN structure for a complex (object/array) schema element.
+     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
+     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
+     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
+     * @returns {CsnElement}
      */
-    getTypeElements(propertyContent) {
+    getTypeElements(propertyContent, docContent, types) {
+        /** @type {CsnElement} */
         let properties = {};
-        let type = this.getTypeFromArray(propertyContent.type);
+        const schema = propertyContent.allOf ? this.flattenAllOf(propertyContent, docContent) : propertyContent;
+        let type = this.getTypeFromArray(schema.type);
 
         // for nested object
         if (type === 'object') {
-            for (const [key, value] of Object.entries(propertyContent.properties)) {
-                properties[key] = this.getTypeElements(value);
+            if (!schema.properties) return {};
+            for (const [key, value] of Object.entries(schema.properties)) {
+                properties[key] = this.getTypeElements(value, docContent, types);
             }
         }
         // for nested array
         else if (type === 'array') {
-            properties.items = this.getTypeElements(propertyContent.items);
+            if (!schema.items || (!schema.items.type && !schema.items['$ref'] && !schema.items.allOf)) return {};
+            properties.items = this.getTypeElements(schema.items, docContent, types);
             return properties;
         }
         // base data type mapping
         else {
-            return this.getPropertyObject(propertyContent);
+            return this.getPropertyObject(schema, docContent, types);
         }
 
         return { elements: properties };
     }
 
     /**
-     * Returns type for the property from the AsyncAPI Document.
-     * @returns the value of type.
+     * Unwraps nullable array type representations to a single type string.
+     * @param {string | string[] | undefined} typeValue
      */
     getTypeFromArray(typeValue) {
         let type;
@@ -288,15 +342,41 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns generated object for a single property.
-     * @returns an object for a property.
+     * Returns the CSN element object for a scalar or $ref property.
+     * @param {AsyncApiSchema} propertyContent - AsyncAPI schema for this property
+     * @param {AsyncApiDocument} docContent - root AsyncAPI document, used to resolve $ref entries
+     * @param {CsnTypeMap} types - accumulator for generated CDS type definitions
      */
-    getPropertyObject(propertyContent) {
+    getPropertyObject(propertyContent, docContent, types) {
+        /** @type {CsnElement} */
         const property = {};
         if ('$ref' in propertyContent) {
-            const refPathParts = propertyContent['$ref'].split('/');
-            const propertyName = refPathParts[refPathParts.length - 1];
-            property['type'] = { 'ref': [refPathParts[3], propertyName] };
+            const refPathParts = (propertyContent['$ref'] ?? '').split('/');
+            const schemaName = refPathParts[3] ?? '';
+            const isWholeSchemaRef = () => refPathParts.length === 4 && refPathParts[1] === 'components' && refPathParts[2] === 'schemas';
+
+            if (isWholeSchemaRef()) {
+                // $ref to a whole top-level schema — resolve it and emit as a CDS type
+                if (!types[schemaName]) {
+                    types[schemaName] = null; // placeholder to guard against circular refs
+                    const resolvedSchema = this.resolveRef(docContent, propertyContent);
+                    const flatSchema = resolvedSchema.allOf ? this.flattenAllOf(resolvedSchema, docContent) : resolvedSchema;
+                    const elements = this.getTypeElements(flatSchema, docContent, types);
+                    // only emit a named type if it has structure; otherwise fall back to LargeString
+                    if (Object.keys(elements).length > 0) {
+                        types[schemaName] = { 'kind': 'type', '@cds.external': 'true', ...elements };
+                    } else {
+                        delete types[schemaName];
+                        property['type'] = 'cds.LargeString';
+                        return property;
+                    }
+                }
+                property['type'] = schemaName;
+            } else {
+                // $ref to a specific property within a schema (e.g. /properties/propName)
+                const propertyName = refPathParts[refPathParts.length - 1];
+                property['type'] = { 'ref': [schemaName, propertyName] };
+            }
             return property;
         }
         const inputType = this.getTypeFromArray(propertyContent.type);
@@ -322,24 +402,26 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Takes the enums from the AsyncAPI Document.
-     * @returns the property object of enums.
+     * @param {Array<*>} enumArray
      */
     getEnumObject(enumArray) {
+        /** @type {Record<string, {}>} */
         const enumProperty = {};
 
         enumArray.forEach(val => {
-            enumProperty[val] = {};
+            enumProperty[String(val)] = {};
         });
 
         return enumProperty;
     }
 
     /**
-     * Takes the type and format from the document and returns the corresponding cds type.
-     * @returns the corresponding cds type.
+     * @param {string | undefined} type - AsyncAPI primitive type
+     * @param {string | null} format - AsyncAPI format string
      */
     getDataType(type, format = null) {
+        if (!type) throw new Error(messages.UNRESOLVED_TYPE + `'${type}'`);
+        /** @type {Record<string, string>} */
         const asyncapiToCdsMapping = {
             'number': 'cds.Double',
             'boolean': 'cds.Boolean',

package/lib/init/projectReader.js

@@ -3,6 +3,7 @@ const { join, resolve, basename } = require('node:path')
 const { execSync } = require('node:child_process')
 const { fs, exists, isfile, isdir, path } = cds.utils
 const { parseXml } = require('./xml')
+const YAML = require('yaml')
 const { REGEX_JAVA_VERSION, JAVA_LTS_VERSIONS } = require('./constants')
 const TRACE = cds.debug('trace')
 
@@ -69,6 +70,7 @@ module.exports = new class ProjectReader {
     readProject() {
         if (!this.appName) this.#setPackageInfo()
         const env = this.env4('production')
+        if (this.isJava) env.build.target = '.'
         const { appVersion, appName, appId, appDescription, jdkVersion } = this
         TRACE?.({ env })
 
@@ -249,8 +251,8 @@ module.exports._readSpringBootConfig = async function (roots = [cds.env.folders.
     for (let r of rootDirs) {
         const file = isfile(join(r, './src/main/resources/application.yaml'))
         if (file) {
-            const yaml = cds.load.yaml(file)
-            for (let yamlDoc of Array.isArray(yaml) ? yaml : [yaml]) {
+            const docs = YAML.parseAllDocuments(fs.readFileSync(file, 'utf-8'))
+            for (let yamlDoc of docs.map(d => d.toJS())) {
                 let cds = yamlDoc?.cds;
                 if (!cds) continue
                 cds = _normalizeSpringBootCfg(cds)

package/lib/init/template/ams/files/package.json.hbs

@@ -4,7 +4,7 @@
     "@sap/ams": "^3"
   },
   "devDependencies": {
-    "@sap/ams-dev": "^2"
+    "@sap/ams-dev": "^3"
   },
   "engines": {
     "node": "^24"

package/lib/init/template/nodejs/index.js

@@ -1,5 +1,5 @@
 const cds = require('../../../cds')
-const { exists, mkdirp, path } = cds.utils
+const { fs: { promises: { cp } }, exists, mkdirp, path } = cds.utils
 const { OPTIONS: { NODEJS, JAVA } } = require('../../constants')
 const term = require('../../../util/term')
 const { merge } = require('../../merge')
@@ -24,10 +24,12 @@ module.exports = class NodejsTemplate extends require('../../plugin') {
 
     async run() {
         const { db, srv, app } = cds.env.folders
-        if (cds.cli.command === 'init' && cds.cli.options.force) {
+        if (cds.cli.command === 'init' || cds.cli.options.force) {
             await renderAndCopy(path.join(__dirname, 'files'), cds.root, { projectName: path.basename(cds.root) })
         } else {
             await merge(__dirname, 'files/package.json.hbs').into('package.json', { with: { projectName: path.basename(cds.root) }})
+            await cp(path.join(__dirname, 'files/eslint.config.mjs'), 'eslint.config.mjs', { force: false })
+            await cp(path.join(__dirname, 'files/.vscode'), '.vscode', { recursive: true, force: false })
         }
         await Promise.all([db, srv, app].map(p => mkdirp(p)))
     }

package/lib/init/template/test/files/test/test.xs.hbs

@@ -19,7 +19,7 @@ describe('{{serviceName}} OData APIs', () => {
   it('serves <%name%>', async () => {
     const { data } = await GET `<%&urlPath%> ${{ params: { $select: '<%&selectString%>' } }}`
     expect(data.value).to.containSubset([
-      <%&elementsString%>,
+      // <%&elementsString%>,
     ])
   })
 <%={{ }}=%>{{/entities}}
@@ -27,7 +27,8 @@ describe('{{serviceName}} OData APIs', () => {
 {{#actions}}{{=<% %>=}}
   it('executes <%name%>', async () => {
     const { data } = await POST `<%&urlPath%> ${
-      <%&paramsString%>
+      {}
+      // <%&paramsString%>
     }`
     // TODO finish this test
     // expect(data.value).to...

package/lib/init/template/xsuaa/index.js

@@ -86,13 +86,17 @@ module.exports = class XsuaaTemplate extends require('../../plugin') {
         if (addKyma || addMultitenancy && hasKyma) {
             const overwrites = addMultitenancy ? [{ item: 'xsuaa.parameters.tenant-mode', withValue: 'shared' }] : []
             await merge(__dirname, 'files/values.yaml.hbs').into('chart/values.yaml', { with: project, overwrites })
-            await merge({
-                xsuaa: {
-                    parameters: {
-                        xsappname: `${project.appName}-{{ .Release.Namespace }}`
-                    }
-                }
-            }).into('chart/values.yaml')
+            const parameters = {
+                xsappname: `${project.appName}-{{ .Release.Namespace }}`
+            }
+            if (!project.hasCustomRoleCollections && xsSecurity['role-templates'].length) {
+                parameters['role-collections'] = xsSecurity['role-templates'].map(role => ({
+                    name: `${role.name} (${project.appName} {{ .Release.Namespace }})`,
+                    description: 'generated',
+                    'role-template-references': [`$XSAPPNAME.${role.name}`],
+                }))
+            }
+            await merge({ xsuaa: { parameters } }).into('chart/values.yaml')
             await KymaTemplate.mergeDependency('service-instance', 'xsuaa')
 
         }

package/node_modules/@cap-js/openapi/lib/compile/csdl.js

@@ -14,7 +14,7 @@ const CDS_TERMS = Object.freeze({
     Core: ['AcceptableMediaTypes', 'Computed', 'ComputedDefaultValue', 'DefaultNamespace', 'Description', 'Example', 'Immutable', 'LongDescription',
         'MediaType', 'OptionalParameter', 'Permissions', 'SchemaVersion'],
     JSON: ['Schema'],
-    Validation: ['AllowedValues', 'Exclusive', 'Maximum', 'Minimum', 'Pattern']
+    Validation: ['AllowedValues', 'Exclusive', 'Maximum', 'MaxItems', 'Minimum', 'MinItems', 'Pattern']
 })
 
 /**
@@ -168,7 +168,7 @@ class CSDLMeta {
 
     /**
      * Construct map of qualified term names
-     * @param {object} alias Map of namespace or alias to alias
+     * @param {*} alias Map of namespace or alias to alias
      */
     #getVocabularies(alias) {
         Object.keys(CDS_TERMS).forEach(vocab => {
@@ -187,7 +187,7 @@ class CSDLMeta {
     /**
      * Find model element by qualified name
      * @param {string} qname Qualified name of model element
-     * @return {object} Model element
+     * @return {*} Model element
      */
     modelElement(qname) {
         const q = nameParts(qname);