@sap/cds-dk 10.2.0 → 10.2.1

package/lib/mtx/push.js

@@ -8,6 +8,7 @@ const buildSystem = require('../build')
 
 const { buildResponseError, buildNetworkError, mtxFetch } = require('./util/request');
 const { getMessage } = require('./util/logging');
+const { bold } = require('../util/term');
 const { schemaRegex } = require('./util/urls');
 
 const JOB_STATUS = {
@@ -58,11 +59,16 @@ module.exports = class Push {
     }
 
     static getExtensionName(projectFolder) {
+        let name;
         try {
-            return require(join(projectFolder, 'package.json')).name;
+            name = require(join(projectFolder, 'package.json')).name;
         } catch (error) {
             throw getMessage(`Extension project at ${projectFolder} is missing package.json file`, { error, command: 'push' });
         }
+        if (typeof name !== 'string' || !name.trim()) {
+            throw getMessage(`Extension project at ${projectFolder} requires a non-empty ${bold('name')} in package.json`, { command: 'push' });
+        }
+        return name;
     }
 
     static async pushTgz(params, tgz, extensionName) {

package/node_modules/@cap-js/asyncapi/README.md

@@ -1,6 +1,6 @@
 [![REUSE status](https://api.reuse.software/badge/github.com/cap-js/asyncapi)](https://api.reuse.software/info/github.com/cap-js/asyncapi)
 
-# AsyncAPI 
+# AsyncAPI
 
 ## About this project
 
@@ -18,20 +18,10 @@ The `@cap-js/asyncapi` is a package that provides support for AsyncAPI document
 ### Installation
 
 ```sh
-$ npm install @cap-js/asyncapi
+npm add -D @cap-js/asyncapi
 ```
 
-### Usage
-
-```js
-const cds = require('@sap/cds')
-const { compile } = require('@cap-js/asyncapi')
-```
-
-```js
-const csn = await cds.load(cds.env.folders.srv)
-const asyncapiDocument = compile(csn)
-```
+See the [AsyncAPI guide](https://cap.cloud.sap/docs/guides/protocols/asyncapi) for the full documentation.
 
 ## Contributing
 
@@ -43,4 +33,4 @@ We as members, contributors, and leaders pledge to make participation in our com
 
 ## Licensing
 
-Copyright 2024 SAP SE or an SAP affiliate company and contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/asyncapi).
+Copyright 2026 SAP SE or an SAP affiliate company and contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/asyncapi).

package/node_modules/@cap-js/asyncapi/cds-plugin.js

@@ -0,0 +1,12 @@
+const cds = require('@sap/cds')
+const { compile, import: asyncapi } = require('./index')
+
+// monkey-patch cds.compile.to and cds.import.from directly, same pattern as cds-dk's lazy getters
+if (cds.compile?.to)  cds.compile.to.asyncapi = compile
+
+if (cds.import?.from) cds.import.from.asyncapi = async function (filepath, options = {}) {
+  const src = await cds.utils.read(filepath, 'utf-8')
+  const csn = asyncapi.asyncapi2csn(src)
+  options.inputFileKind = 'odata'
+  return csn
+}

package/node_modules/@cap-js/asyncapi/index.js

@@ -1,4 +1,5 @@
 
 module.exports = {
-    compile: require('./lib/compile')
-}
+    compile: require('./lib/compile'),
+    import: require('./lib/import')
+}

package/node_modules/@cap-js/asyncapi/lib/compile/components/messages/index.js

@@ -125,6 +125,7 @@ function eventToMessage(definition, name, presets, i18nBundle) {
 
     let messageObj = {
         name,
+        'x-service-name': definition._service.name,
         headers: {
             type: 'object',
             properties: getHeaderProperties(name)
@@ -157,8 +158,9 @@ function entriesToMessages(definitions, events, presets, i18nBundle) {
     const messages = {}
 
     events.forEach(event => {
-        let name = getEventName(event, definitions[event])
-        messages[name] = eventToMessage(definitions[event], name, presets, i18nBundle)
+        const definition = definitions[event]
+        let name = getEventName(event, definition)
+        messages[name] = eventToMessage(definition, name, presets, i18nBundle)
     })
 
     return messages

package/node_modules/@cap-js/asyncapi/lib/compile/components/schemas/definition.js

@@ -1,5 +1,6 @@
 const { addEnum } = require('./enum')
 const schemaUtils = require('./utils')
+const { makeNullable } = require('./utils')
 const { cacheAndReturn, getCache } = require('./cache')
 const { getOwnValue } = require('../../utils')
 const { toLocalizedArray } = require('./localized')
@@ -30,6 +31,7 @@ function elementsToSchema(schemaCache, definitions, entry, nullable, i18nBundle)
   const object = schemaUtils.getBaseTypeStructure('object')
   for (const [name, element] of Object.entries(entry.elements)) {
     if (getOwnValue(element, 'key')
+        || getOwnValue(element, 'notNull')
         || getOwnValue(element, '@mandatory')
         || (getOwnValue(element, '@Common.FieldControl') && getOwnValue(element['@Common.FieldControl'], '#') === 'Mandatory')
     ) {
@@ -44,7 +46,15 @@ function elementsToSchema(schemaCache, definitions, entry, nullable, i18nBundle)
       object.properties = {}
     }
 
-    object.properties[name] = addAnnotations(element, elementToSchema(schemaCache, definitions, element, i18nBundle), i18nBundle)
+    let propSchema = addAnnotations(element, elementToSchema(schemaCache, definitions, element, i18nBundle), i18nBundle)
+    if (!getOwnValue(element, 'notNull')
+        && !getOwnValue(element, 'key')
+        && !getOwnValue(element, '@mandatory')
+        && !(getOwnValue(element, '@Common.FieldControl') && getOwnValue(element['@Common.FieldControl'], '#') === 'Mandatory')
+    ) {
+      propSchema = makeNullable(propSchema)
+    }
+    object.properties[name] = propSchema
   }
 
   if (required.length) {

package/node_modules/@cap-js/asyncapi/lib/compile/components/schemas/utils.js

@@ -88,10 +88,26 @@ function isRefEntry(entry) {
     return typeof type === 'object' && !!type && 'ref' in type && Array.isArray(type.ref)
 }
 
+function makeNullable(schema) {
+    const type = schema.type
+    const nullableSchema = { ...schema }
+
+    if (type && !Array.isArray(type)) {
+        nullableSchema.type = [type, 'null']
+    }
+
+    if (Array.isArray(nullableSchema.enum) && !nullableSchema.enum.includes(null)) {
+        nullableSchema.enum = [...nullableSchema.enum, null]
+    }
+
+    return nullableSchema
+}
+
 module.exports = {
     toString,
     getBaseTypeStructure,
     getFormatStructure,
+    makeNullable,
     isAssociation,
     isComposition,
     isStructured,

package/node_modules/@cap-js/asyncapi/lib/compile/utils.js

@@ -5,11 +5,12 @@
  * @return {string} The event type name
  */
 function getEventName(eventName, eventDefinition) {
-
     if (eventDefinition['@AsyncAPI.EventType']) {
-        eventName = eventDefinition['@AsyncAPI.EventType']
+        return eventDefinition['@AsyncAPI.EventType']
+    }
+    if (eventDefinition['@topic']) {
+        return eventDefinition['@topic']
     }
-
     return eventName
 }
 

package/node_modules/@cap-js/asyncapi/lib/import/importAsyncAPI.js

@@ -0,0 +1,34 @@
+const ParserContext = require('./parserContext')
+const { join } = require('path')
+const version = require(join(__dirname, '..', '..', 'package.json')).version
+
+function importAsyncAPI(input) {
+    const context = new ParserContext(input)
+    return convertToCSN(context)
+}
+
+function convertToCSN(context) {
+    const csn = {
+        meta: {
+            creator: `@cap-js/asyncapi ${version}`
+        },
+        $version: '2.0',
+        definitions: {}
+    }
+
+    Object.entries(context.services).forEach(([key, value]) => {
+        const events = value.events
+        const types = value.types
+        delete value.events
+        delete value.types
+
+        csn.definitions[key] = value
+        Object.assign(csn.definitions, events, types)
+    })
+
+    return csn
+}
+
+module.exports = {
+    importAsyncAPI
+}

package/node_modules/@cap-js/asyncapi/lib/import/index.js

@@ -0,0 +1,18 @@
+const { importAsyncAPI } = require('./importAsyncAPI')
+const { validateAsyncAPI } = require('./utils')
+
+/**
+ * The starting function for conversion of AsyncAPI document to csn
+ * @returns AsyncAPI document
+ */
+function asyncapi2csn(source) {
+    // validate asyncapi document
+    const content = JSON.parse(source)
+    validateAsyncAPI(content)
+
+    return importAsyncAPI(content)
+}
+
+module.exports = {
+    asyncapi2csn
+}

package/node_modules/@cap-js/asyncapi/lib/import/message.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const errorMessages = {
+    INVALID_ASYNCAPI_FILE: 'The AsyncAPI file is not valid. Specify the correct AsyncAPI file.',
+    INVALID_MESSAGE_NAME: 'The message name is not valid.',
+    UNRESOLVED_TYPE: 'Could not resolve the type: ',
+}
+
+module.exports = errorMessages

package/node_modules/@cap-js/asyncapi/lib/import/parserContext.js

@@ -0,0 +1,368 @@
+const { parseMessageName } = require('./utils')
+const messages = require('./message')
+
+module.exports = class ParserContext {
+    /**
+     * @constructor
+     */
+    constructor(content) {
+        this.services = this.getServicesFromContent(content)
+    }
+
+    getTopicName(eventName) {
+        return eventName.startsWith('ce/') ? eventName.substring(3) : eventName
+    }
+
+    /**
+     * Returns services from the asyncapi json object along with the events and annotations.
+     * @returns an object with all the services.
+     */
+    getServicesFromContent(content) {
+        const services = {}
+        const serviceAnnotations = this.getServiceAnnotations(content)
+
+        Object.entries(content.components.messages).forEach(([, value]) => {
+            let eventName
+            // Message name should be used to capture the event name
+            if (value.name) {
+                eventName = value.name
+            } else {
+                throw new Error(messages.INVALID_ASYNCAPI_FILE)
+            }
+            // uses regex to break event name in different components
+            // x-sap-cds-service-name is set by the CAP exporter and is the authoritative
+            // service key — use it directly to avoid parsing the message name string.
+            const service = value['x-service-name'] ?? parseMessageName(eventName, content['x-sap-application-namespace'])[1]
+            const event = eventName
+
+            // add service to services entry if not present
+            if (!(service in services)) {
+                services[service] = { 'kind': 'service', '@cds.external': 'true', ...serviceAnnotations, 'events': {}, 'types': {} }
+            }
+
+            // add event entry to service
+            const eventAnnotations = this.getEventAnnotations(value)
+
+            // add topic annotation
+            eventAnnotations['@topic'] = this.getTopicName(eventName)
+            let properties = {}
+            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)
+            }
+            services[service].types = types
+            services[service].events[event] = { 'kind': 'event', '@cds.external': 'true', ...eventAnnotations, elements: properties }
+        })
+
+        return services
+    }
+
+    /**
+     * Returns annotations of a particular service.
+     * @returns an object with all the annotations as key value pairs.
+     */
+    getServiceAnnotations(content) {
+        const serviceAnnotationsMapping = {
+            'x-sap-stateInfo': 'StateInfo', // expected: object
+            'x-sap-shortText': 'ShortText' // expected: string
+        }
+
+        const infoAnnotationsMapping = {
+            'title': 'Title', // expected: string
+            'version': 'SchemaVersion', // expected: string
+            'description': 'Description' // expected: string
+        }
+
+        const annotations = this.getAnnotations(content, serviceAnnotationsMapping)
+
+        if (content.info) {
+            for (const [key, value] of Object.entries(infoAnnotationsMapping)) {
+                if (content.info[key] && !(content.info[key] instanceof Object)) {
+                    // info values will always be in string format
+                    annotations['@AsyncAPI.' + value] = content.info[key]
+                }
+            }
+        }
+
+        return annotations
+    }
+
+    /**
+     * Returns annotations of a particular event. Here the parameter content is event content.
+     * @returns an object with all the annotations as key value pairs.
+     */
+    getEventAnnotations(content) {
+        const eventLevelAnnotationsMapping = {
+            'x-sap-event-spec-version': 'EventSpecVersion', // expected: string
+            'x-sap-event-source': 'EventSource', // expected: string
+            'x-sap-event-version': 'EventSchemaVersion', // expected: string
+            'x-sap-event-source-parameters': 'EventSourceParams', // expected: object
+            'x-sap-event-characteristics': 'EventCharacteristics', // expected: object
+            'x-sap-stateInfo': 'EventStateInfo' // expected: object
+        }
+
+        const annotations = this.getAnnotations(content, eventLevelAnnotationsMapping)
+
+        return annotations
+    }
+
+    /**
+     * 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.
+     */
+    isValidAnnotationValue(annotation, value) {
+        const objectTypeAnnotations = ['StateInfo', 'EventSourceParams', 'EventCharacteristics', 'EventStateInfo']
+        // if the value is an array or null
+        if (Array.isArray(value) || value === null) return false
+
+        if (objectTypeAnnotations.includes(annotation) && (value instanceof Object)) {
+            return true
+        } else if ((!objectTypeAnnotations.includes(annotation)) && (typeof value === 'string')) {
+            return true
+        } else {
+            console.warn('WARNING: Annotations which are not following the expected type are omitted.')
+            return false
+        }
+    }
+
+    /**
+     * 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.
+     */
+    getAnnotations(content, annotationsMapping) {
+        const annotations = {}
+
+        for (const [key, value] of Object.entries(content)) {
+            // case: known annotation
+            if (annotationsMapping[key] && this.isValidAnnotationValue(annotationsMapping[key], value)) {
+                annotations['@AsyncAPI.' + annotationsMapping[key]] = value
+            }
+            // case: unkown annotation
+            else if (key.startsWith('x-')) {
+                if (!annotations['@AsyncAPI.Extensions']) {
+                    annotations['@AsyncAPI.Extensions'] = {}
+                }
+                // removes x- from the element
+                annotations['@AsyncAPI.Extensions'][key.substring(2)] = value
+            }
+        }
+
+        return annotations
+    }
+
+    /**
+     * Returns the referred schema. Here the content is the asyncapi
+     * document and payloadObject is the reference path
+     * @returns an object with the referred schema.
+     */
+    resolveRef(content, payloadObject) {
+        let schema = {}
+
+        if (payloadObject['$ref']) {
+            const pathArray = payloadObject['$ref'].split('/')
+            pathArray.forEach((value) => {
+                if (value === '#') schema = content
+                else if (schema[value]) schema = schema[value]
+                // in case path doesn't exist in the file
+                else schema = {}
+            })
+
+            if (!Object.keys(schema).length) {
+                console.warn('WARNING: Unable to resolve ref path: ' + payloadObject['$ref'])
+            }
+        }
+        else if (payloadObject instanceof Object) {
+            // in case ref is not there and schema object is there
+            schema = payloadObject
+        }
+
+        return schema
+    }
+
+    /**
+     * Returns the properties and types generated, related to an event.
+     * @returns a properties object and a types object.
+     */
+    getPropertiesAndTypes(eventName, content) {
+        const properties = {}
+        let 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 }
+            }
+        }
+        return [properties, types]
+    }
+
+    /**
+     * Returns the processed objects for property and type.
+     * @returns property object and type object.
+     */
+    parseProperty(eventName, propertyName, propertyContent, isRequired) {
+        let property = {}
+        let propertyAttributes
+        let types = {}
+
+        if (isRequired === true) {
+            property['@mandatory'] = true
+        }
+
+        let type = this.getTypeFromArray(propertyContent.type)
+
+        // case where type is defined
+        if (type && (type === 'object' || type === 'array')) {
+            // for generation of type: event name + property name
+            propertyName = propertyName[0].toUpperCase() + propertyName.substring(1)
+            let typeName = eventName + '.' + propertyName
+            // generate object for the introduced type
+            const elements = this.getTypeElements(propertyContent)
+            types[typeName] = { 'kind': 'type', '@cds.external': 'true', ...elements }
+            // referring to the generated type from the property
+            propertyAttributes = { 'type': typeName }
+        } else {
+            propertyAttributes = this.getPropertyObject(propertyContent)
+        }
+        property = { ...property, ...propertyAttributes }
+
+        return [property, types]
+    }
+
+    /**
+     * Returns generated type for the property.
+     * @returns an object for a type.
+     */
+    getTypeElements(propertyContent) {
+        let properties = {}
+        let type = this.getTypeFromArray(propertyContent.type)
+
+        // for nested object
+        if (type === 'object') {
+            for (const [key, value] of Object.entries(propertyContent.properties)) {
+                properties[key] = this.getTypeElements(value)
+            }
+        }
+        // for nested array
+        else if (type === 'array') {
+            properties.items = this.getTypeElements(propertyContent.items)
+            return properties
+        }
+        // base data type mapping
+        else {
+            return this.getPropertyObject(propertyContent)
+        }
+
+        return { elements: properties }
+    }
+
+    /**
+     * Returns type for the property from the AsyncAPI Document.
+     * @returns the value of type.
+     */
+    getTypeFromArray(typeValue) {
+        let type
+        // if type is an array
+        if (Array.isArray(typeValue)) {
+            // one of the value will be null
+            type = typeValue[0] === 'null' ? typeValue[1] : typeValue[0]
+        } else {
+            type = typeValue
+        }
+
+        return type
+    }
+
+    /**
+     * Returns generated object for a single property.
+     * @returns an object for a property.
+     */
+    getPropertyObject(propertyContent) {
+        const property = {}
+        if ('$ref' in propertyContent) {
+            const refPathParts = propertyContent['$ref'].split('/')
+            const propertyName = refPathParts[refPathParts.length - 1]
+            property['type'] = { 'ref': [refPathParts[3], propertyName] }
+            return property
+        }
+        const inputType = this.getTypeFromArray(propertyContent.type)
+        const cdsType = this.getDataType(inputType, propertyContent.format)
+
+        property['type'] = cdsType
+
+        // case: cds type is decimal
+        if (cdsType === 'cds.Decimal') {
+            if (propertyContent['x-sap-precision']) property.precision = propertyContent['x-sap-precision']
+            if (propertyContent['x-sap-scale']) property.scale = propertyContent['x-sap-scale']
+        }
+
+        if (propertyContent['default']) {
+            property['default'] = { 'val': propertyContent['default'] }
+        }
+
+        if (propertyContent['enum']) {
+            property['enum'] = this.getEnumObject(propertyContent['enum'])
+        }
+
+        return property
+    }
+
+    /**
+     * Takes the enums from the AsyncAPI Document.
+     * @returns the property object of enums.
+     */
+    getEnumObject(enumArray) {
+        const enumProperty = {}
+
+        enumArray.forEach(val => {
+            enumProperty[val] = {}
+        })
+
+        return enumProperty
+    }
+
+    /**
+     * Takes the type and format from the document and returns the corresponding cds type.
+     * @returns the corresponding cds type.
+     */
+    getDataType(type, format = null) {
+        const asyncapiToCdsMapping = {
+            'number': 'cds.Double',
+            'boolean': 'cds.Boolean',
+            'integer': 'cds.Integer'
+        }
+
+        if (type === 'string') {
+            switch (format) {
+                case 'int64':
+                    return 'cds.Integer64'
+                case 'decimal':
+                    return 'cds.Decimal'
+                case 'uuid':
+                    return 'cds.UUID'
+                case 'date':
+                    return 'cds.Date'
+                case 'partial-time':
+                    return 'cds.Time'
+                case 'date-time':
+                    return 'cds.Timestamp'
+                default:
+                    return 'cds.LargeString'
+            }
+        } else if (asyncapiToCdsMapping[type]) {
+            return asyncapiToCdsMapping[type]
+        } else {
+            throw new Error(messages.UNRESOLVED_TYPE + `'${type}'`)
+        }
+    }
+}