@sap/cds-dk 10.1.2 → 10.2.1

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}'`)
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+const messages = require('./message')
+
+function validateAsyncAPI(content) {
+    if ('channels' in content && 'components' in content && 'messages' in content.components) {
+        return
+    }
+
+    throw new Error(messages.INVALID_ASYNCAPI_FILE)
+}
+
+/**
+ * Accepted scenarios:
+ * * with version info : <namespace>.<businessObject>.<operation>.<version>
+ * * without version info : <namespace>.<businessObject>.<operation>
+ *
+ * ? Is it mandatory for <namespace> to always follow small case notation?
+ * ? Is it mandatory for <businessObject> to follow Camel Case or Upper Came Case notation?
+ *
+ * ToDo: Can we support `-` in operations?
+ */
+const regExp = new RegExp(
+    '^(?<namespace>(?:[a-z][a-z0-9]*)(?:[.][a-z][a-z0-9]*)+)[.](?<businessObject>[a-zA-Z0-9]+)[.](?<operation>[a-zA-Z0-9]+)[.]?(?<version>v(?:[0-9]|[1-9][0-9]*))?$'
+)
+
+/**
+ * Validates the messages' `key` with the regExp and returns the regEx groups.
+ * @returns regexGroups
+ */
+function getRegExpGroups(key) {
+    /**
+     * Result format:
+     * index 0: key
+     * index 1: <namespace> value
+     * index 2: <businessObject> value
+     * index 3: <operation> value
+     * index 4: <version> value; undefined if <version> is optional
+     */
+    const regExpGroups = regExp.exec(key)
+
+    if (regExpGroups == null) {
+        throw new Error(messages.INVALID_MESSAGE_NAME)
+    }
+    return regExpGroups
+}
+
+/**
+ * Parses a message name into a [fullName, serviceName] pair.
+ *
+ * Two formats are supported:
+ *
+ * 1. SAP event-catalog format: `<namespace>.<BusinessObject>.<Operation>[.v<n>]`
+ *    where <namespace> is ≥2 lowercase dot-separated segments (e.g. `sap.s4.beh`).
+ *    Detected by matching the strict regex; service key = namespace + '.' + businessObject.
+ *
+ * 2. CAP-produced format: `<ServiceName>.<EventName>` (optionally nested), where the
+ *    first segment is always the PascalCase CDS service name.
+ *    Detected by the presence of `x-sap-application-namespace` in the AsyncAPI document.
+ *
+ * @param {string} key - The message name to parse
+ * @param {string|undefined} applicationNamespace - Value of `x-sap-application-namespace`
+ *   from the AsyncAPI document, or undefined if absent
+ * @returns {Array} [fullName, serviceName]
+ */
+function parseMessageName(key, applicationNamespace) {
+    const regExpGroups = regExp.exec(key)
+    if (regExpGroups != null) {
+        const serviceKey = regExpGroups[1] + '.' + regExpGroups[2]
+        return [regExpGroups[0], serviceKey]
+    }
+
+    if (applicationNamespace) {
+        const segments = key.split('.')
+        if (segments.length >= 2) {
+            return [key, segments[0]]
+        }
+    }
+
+    throw new Error(messages.INVALID_MESSAGE_NAME)
+}
+
+module.exports = {
+    validateAsyncAPI,
+    getRegExpGroups,
+    parseMessageName
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/asyncapi",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CAP tool for AsyncAPI",
   "repository": {
     "type": "git",
@@ -16,9 +16,14 @@
   "author": "SAP SE (https://www.sap.com)",
   "license": "Apache-2.0",
   "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./cds-plugin": "./cds-plugin.js"
+  },
   "files": [
     "lib/",
     "index.js",
+    "cds-plugin.js",
     "LICENSE"
   ],
   "scripts": {
@@ -29,6 +34,89 @@
     "@sap/cds": ">=7.6"
   },
   "devDependencies": {
+    "@sap/cds-dk": "^10",
     "eslint": "^10.0.0"
+  },
+  "cds": {
+    "schema": {
+      "export": {
+        "asyncapi": {
+          "type": "object",
+          "description": "AsyncAPI settings for cds compile",
+          "additionalProperties": false,
+          "properties": {
+            "application_namespace": {
+              "type": "string",
+              "description": "The registered namespace of the application"
+            },
+            "merged": {
+              "type": "object",
+              "description": "properties that needs to be there when merged option is used",
+              "additionalProperties": false,
+              "properties": {
+                "title": {
+                  "type": "string",
+                  "description": "Title to be used for merged doc"
+                },
+                "version": {
+                  "type": "string",
+                  "description": "Version to be used for merged doc"
+                },
+                "short_text": {
+                  "type": "string",
+                  "description": "Short description of the AsyncAPIs"
+                },
+                "description": {
+                  "type": "string",
+                  "description": "Description to be used for the merged doc"
+                }
+              }
+            },
+            "event_spec_version": {
+              "type": "string",
+              "description": "Mentions the version of AsyncAPI spec"
+            },
+            "event_source": {
+              "type": "string",
+              "description": "Event source information",
+              "default": "{region}/{applicationNamespace}/{instanceId}"
+            },
+            "event_source_params": {
+              "type": "object",
+              "description": "Parameters related to the source of event",
+              "default": {
+                "region": "the region",
+                "applicationNamespace": "the namespace",
+                "instanceId": "the instance id"
+              },
+              "additionalProperties": false,
+              "properties": {
+                "region": {
+                  "type": "string",
+                  "description": "The regional context of the application"
+                },
+                "applicationNamespace": {
+                  "type": "string",
+                  "description": "The registered namespace of the application"
+                },
+                "instanceId": {
+                  "type": "string",
+                  "description": "The instance id (tenant, installation, ...) of the application."
+                }
+              }
+            },
+            "event_characteristics": {
+              "type": "object",
+              "description": "The characteristics defined for events",
+              "additionalProperties": true
+            }
+          }
+        }
+      },
+      "importFrom": {
+        "const": "asyncapi",
+        "description": "AsyncAPI specification"
+      }
+    }
   }
 }

package/node_modules/@cap-js/db-service/CHANGELOG.md

@@ -4,6 +4,16 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.1.2](https://github.com/cap-js/cds-dbs/compare/db-service-v3.1.1...db-service-v3.1.2) (2026-10-09)
+
+
+### Fixed
+
+* allow path expressions in infix filter of expands ([#1755](https://github.com/cap-js/cds-dbs/issues/1755)) ([cbe4f65](https://github.com/cap-js/cds-dbs/commit/cbe4f659add279fdb4155aad6bc155552dd276db))
+* **cqn2pql:** handle parameterized views in from_args ([#1738](https://github.com/cap-js/cds-dbs/issues/1738)) ([8f4dc35](https://github.com/cap-js/cds-dbs/commit/8f4dc354022b861569eab014cb469d4259c91278))
+* Primary keys were not resolved for localized. entities ([#1749](https://github.com/cap-js/cds-dbs/issues/1749)) ([410eef8](https://github.com/cap-js/cds-dbs/commit/410eef8f4487bd8e0c8b5a34a3637959095e255b))
+* recurse into xpr nodes in collectDistanceTo ([#1746](https://github.com/cap-js/cds-dbs/issues/1746)) ([c5dc20d](https://github.com/cap-js/cds-dbs/commit/c5dc20d8c1cd467aec4df3a33f0b6abe43027fe8))
+
 ## [3.1.1](https://github.com/cap-js/cds-dbs/compare/db-service-v3.1.0...db-service-v3.1.1) (2026-09-15)