@sap/cds-dk 10.0.6 → 10.0.7

package/CHANGELOG.md

@@ -6,6 +6,19 @@ 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

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/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/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);