@sap/cds-dk 10.0.7 → 10.1.1

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

@@ -3,6 +3,7 @@ const cds = require('../../../cds')
 const { normalizePath } = require('../../util')
 const { BUILD_TASK_FIORI, CDS_CONFIG_PATH_SEP } = require('../../constants')
 const DEBUG = cds.debug('cli|build')
+const { exists } = cds.utils
 
 /**
  * With cds 4 service metadata for the UI service binding is no longer created by default.
@@ -86,7 +87,8 @@ module.exports = class FioriBuildPlugin extends require('../edmx') {
     }
 
     async _writeEdmxToWebapp(src, dest) {
-        const manifestPath = path.join(src, 'webapp', 'manifest.json')
+        const subfolder = this._resolveAppFolder(src)
+        const manifestPath = path.join(src, subfolder, 'manifest.json')
         let manifest
 
         try {
@@ -124,10 +126,37 @@ module.exports = class FioriBuildPlugin extends require('../edmx') {
             return
         }
 
-        const edmxPath = path.resolve(path.join(dest, 'webapp'), this._strippedUrlPath(localUri))
+        const edmxPath = path.resolve(path.join(dest, subfolder), this._strippedUrlPath(localUri))
         return this.write(edmx).to(edmxPath)
     }
 
+    /**
+     * Folder holding manifest.json relative to the UI module root.
+     * Defaults: `webapp` (UI5 v4 application), `src` (UI5 v5 component/library);
+     * overridable via ui5.yaml path mapping, see https://ui5.github.io/cli/v4/pages/Configuration/#path-mapping
+     */
+    _resolveAppFolder(src) {
+        for (const yamlFile of ['ui5.yaml', 'ui5-build.yaml']) {
+            const yamlPath = path.join(src, yamlFile)
+            if (!exists(yamlPath)) {
+                continue
+            }
+            let paths
+            try {
+                paths = cds.load.yaml(yamlPath)?.resources?.configuration?.paths
+            } catch (e) {
+                if (e.name !== 'YAMLParseError') throw e // only tolerate malformed yaml
+                DEBUG?.(`ignoring malformed [${path.relative(cds.root, yamlPath)}]: ${e.code}`)
+                continue
+            }
+            const mapped = paths?.webapp ?? paths?.src
+            if (mapped) {
+                return mapped
+            }
+        }
+        return exists(path.join(src, 'src', 'manifest.json')) ? 'src' : 'webapp'
+    }
+
     _getEdmxForUri(model, appFolder, uri) {
         const uriSegments = this._strippedUrlPath(uri).split('/')
 

package/lib/build/plugins/internal.js

@@ -142,10 +142,12 @@ module.exports = class InternalBuildPlugin extends require('./plugin') {
     /**
      * Collect and write message bundles from CAP plugins into messages.properties files.
      * @param {string} bundleDest
-     * @param {Object} model - the CSN model (used for neighborhood resolution of message files)
+     * @param {Object} model - passed for signature consistency with subclass overrides; not used here
+     * as Java does not require neighborhood resolution of plugin i18n files.
      */
+    // eslint-disable-next-line no-unused-vars
     async collectMessageBundles(bundleDest, model) {
-        const messageBundle = cds.i18n.bundle4('messages', { model })
+        const messageBundle = cds.i18n.bundle4('messages')
         const messagesData = messageBundle.translations4?.(cds.env.i18n.languages) ?? {}
 
         // Write messages.properties files for each locale

package/lib/build/plugins/mtx-sidecar/index.js

@@ -122,14 +122,13 @@ module.exports = class MtxSidecarBuildPlugin extends require('../nodejs') {
         // resources are determined based on available database build task, SQLite as fallback
         promises.push(new ResourcesTarBuilder(this).createTar(destMain, model))
 
-        // copy package.json and .cdsrc.json from project root
-        const packageJson = path.join(cds.root, 'package.json')
-        const cdsrcJson = path.join(cds.root, '.cdsrc.json')
-        if (exists('package.json')) {
-            promises.push(this.copy(packageJson).to(path.join(destMain, 'package.json')))
-        }
-        if (exists('.cdsrc.json')) {
-            promises.push(this.copy(cdsrcJson).to(path.join(destMain, '.cdsrc.json')))
+        // copy package.json and .cdsrc.json/.cdsrc.yaml from project root
+        for (const file of ['package.json', '.cdsrc.json', '.cdsrc.yaml']) {
+            if (exists(file)) {
+                promises.push(this
+                    .copy(path.join(cds.root, file))
+                    .to(path.join(destMain, file)))
+            }
         }
         return Promise.all(promises)
     }

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

@@ -3,7 +3,7 @@ const { path, exists, rimraf, isdir, read, write } = cds.utils
 const cmd = require('../../../util/command')
 const { BuildError, getWorkspaces, findWorkspaceRoot, normalizePath } = require('../../util')
 const { ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
-    CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
+    CONTENT_NPMRC, CONTENT_CDSRC, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
     OPTION_WS_PACK, SEVERITY_WARNING } = require('../../constants');
 const LOG = cds.log('cli|build')
 const DEBUG = cds.debug('cli|build')
@@ -68,6 +68,7 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
         if (this.isStagingBuild()) {
             const srcSrv = this.task.src === cds.root ? path.resolve(this.task.src, cds.env.folders.srv) : this.task.src
             await this._copyNativeContent(cds.root, srcSrv, destRoot, destSrv)
+            await this.#copyWorkspaceLock(destRoot)
             try {
                 // add minimal node engine to effective package.json.
                 // CloudFoundry uses this entry to choose the node engine in buildpack and may
@@ -146,6 +147,18 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
 
     }
 
+    // copy the workspace root lock into gen/srv when the module has none, so monorepo deployments install frozen dependencies
+    async #copyWorkspaceLock(destRoot) {
+        if (this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false)) return
+        if (exists(path.join(destRoot, 'package-lock.json'))) return
+        const wsRoot = findWorkspaceRoot(cds.root)
+        if (!wsRoot || wsRoot === cds.root) return
+        const rootLock = path.join(wsRoot, 'package-lock.json')
+        if (!exists(rootLock)) return
+        DEBUG?.(`Copying workspace root package-lock.json from '${wsRoot}' into build destination`)
+        await this.copy(rootLock).to(path.join(destRoot, 'package-lock.json'))
+    }
+
     async clean() {
         // staging build content is deleted by default
         if (cds.env.build.target === '.') {
@@ -175,7 +188,7 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
      * @returns the list of files that have been copied
      */
     async copySrvContent(src, destRoot, destSrv) {
-        const srvRootBlockList = RegExp('package\\.json$|package-lock\\.json$|\\.npmrc$|\\.cdsrc\\.json$')
+        const srvRootBlockList = RegExp('package\\.json$|package-lock\\.json$|\\.npmrc$|\\.cdsrc\\.json$|\\.cdsrc\\.yaml$')
         const srvBlockList = RegExp('\\.cds$|csn\\.json$|\\.csn$|manifest\\.y.?ml$|\\.env($|\\..*$)|default-env\\.json$|\\.cdsrc-private.json$')
         const srvRootFileNames = []
 
@@ -201,7 +214,7 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
         let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
         srvAllowList += !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? "|package-lock\\.json$" : ""
         srvAllowList += !this.hasBuildOption(CONTENT_NPMRC, false) ? "|\\.npmrc$" : ""
-        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC_JSON, false) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC, false) ? "|\\.cdsrc\\.json$|\\.cdsrc\\.yaml$" : ""
         srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
         srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
         srvAllowList = new RegExp(srvAllowList)
@@ -228,7 +241,7 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
         let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
         srvAllowList += !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? "|package-lock\\.json$" : ""
         srvAllowList += !this.hasBuildOption(CONTENT_NPMRC, false) ? "|\\.npmrc$" : ""
-        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC_JSON, false) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += !this.hasBuildOption(CONTENT_CDSRC, false) ? "|\\.cdsrc\\.json$|\\.cdsrc\\.yaml$" : ""
         srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
         srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
         srvAllowList = new RegExp(srvAllowList)
@@ -290,18 +303,48 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
                 }
             }
         }
+        await this._packWorkspaceRoot(dest, wsRoot, appPkg)
+    }
+
+    async _packWorkspaceRoot(dest, wsRoot, appPkg) {
+        if (!wsRoot || wsRoot === cds.root) return
+        // The workspace root package is not a member of its own `workspaces` globs, so
+        // `getWorkspaces` never returns it. Pack it explicitly when the app depends on it
+        // via a `file:` spec that resolves to the workspace root.
+        const rootName = require(path.join(wsRoot, 'package.json')).name
+        const spec = appPkg.dependencies?.[rootName]
+        if (!spec?.startsWith('file:')) return
+        if (path.resolve(cds.root, spec.slice('file:'.length)) !== path.resolve(wsRoot)) return
+        let pkgDescriptors
+        try {
+            pkgDescriptors = await NodejsBuildPlugin._execNpmPack(dest, wsRoot)
+        } catch (e) {
+            DEBUG?.(e)
+            throw new BuildError(`Failed to package npm workspace root\n${e.message}`)
+        }
+        const pkgDescriptor = pkgDescriptors?.find(d => d.name === rootName)
+        if (!pkgDescriptor) return
+        const { filename: fileName } = pkgDescriptor
+        appPkg.dependencies[rootName] = `file:${fileName}`
+        this.pushFile(path.join(dest, fileName))
+        await this.write(JSON.stringify(appPkg, 0, 2)).to(path.join(dest, 'package.json'))
     }
 
     /**
      * @param {import('fs').PathLike} dest - destination folder
      * @param {import('fs').PathLike} wsRoot - workspace root folder
-     * @param {string[]} workspaces - list of workspace names
+     * @param {string[]} [workspaces] - list of workspace names; when omitted, the workspace root package itself is packed
      * @returns {Promise<object[]>} - array of pack descriptors ({ name, filename, ... })
      * @private
      */
     static async _execNpmPack(dest, wsRoot, workspaces) {
-        const args = ['pack', '--ws', '--json', `--pack-destination=${dest}`]
-        workspaces.forEach(w => args.push(`-w=${w}`))
+        const args = ['pack', '--json', `--pack-destination=${dest}`]
+        if (workspaces) {
+            args.push('--ws')
+            workspaces.forEach(w => args.push(`-w=${w}`))
+        } else {
+            args.push(wsRoot)
+        }
         const result = await cmd.spawnCommand('npm', args, { cwd: wsRoot }, true, !!LOG._debug)
         DEBUG?.(result)
         const parsed = JSON.parse(result)
@@ -309,4 +352,18 @@ module.exports = class NodejsBuildPlugin extends require('../edmx') {
         // package name as of npm 12 — normalize to an array of descriptors.
         return Array.isArray(parsed) ? parsed : Object.values(parsed)
     }
+
+    // Override to pass model for neighborhood resolution of plugin i18n files.
+    // Cannot be done in InternalBuildPlugin because Java relies on the model-less behaviour.
+    async collectMessageBundles(bundleDest, model) {
+        const messageBundle = cds.i18n.bundle4('messages', { model })
+        const messagesData = messageBundle.translations4?.(cds.env.i18n.languages) ?? {}
+        for (const [locale, messages] of Object.entries(messagesData)) {
+            if (Object.keys(messages).length > 0) {
+                const fileName = locale ? `messages_${locale}.properties` : 'messages.properties'
+                const content = Object.entries(messages).map(([k, v]) => `${k}=${v}`).join('\n') + '\n'
+                await this.write(content).to(path.join(bundleDest, fileName))
+            }
+        }
+    }
 }

package/lib/build/util.js

@@ -8,7 +8,6 @@ const { exists } = cds.utils
 const execAsync = require('node:util').promisify(cp.exec)
 const { isRoot } = require('../util/fs')
 
-const IS_WIN = require('node:os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS, NODEJS_MODEL_EXCLUDE_LIST } = require('./constants');
 const DEBUG = cds.debug('cli|build')
 
@@ -288,7 +287,7 @@ const _cachedWsRoots = new Map()
  * could contain globs. Glob resolution will be supported.
  * The result is cached by workspace root!
  * natively in the future (fs.glob is in experimental state as of Node23).
- * @param {import('fs').PathLike} wsRoot - the root directory of the workspace
+ * @param {string} wsRoot - the root directory of the workspace
  * @returns {Promise<string[]>} list of package paths, or an empty array if either
  * no workspaces are defined or have not been installed.
  */
@@ -302,8 +301,7 @@ async function _execNpmWs(wsRoot) {
     try {
         const cmdLine = 'npm ls --ws --json'
         DEBUG?.(`execute ${cmdLine}`)
-        // @ts-expect-error - TODO: shell should be a string. But can probably be removed altogether?
-        const { stdout } = await execAsync(cmdLine, { shell: IS_WIN, stdio: ['inherit', 'pipe', 'inherit'], cwd: wsRoot })
+        const { stdout } = await execAsync(cmdLine, { cwd: wsRoot })
         const jsonResult = JSON.parse(stdout)
         if (jsonResult.dependencies) {
             result = Object.keys(jsonResult.dependencies)

package/lib/compile/to_asyncapi.js

@@ -4,4 +4,4 @@ function cds_compile_to_asyncapi (csn, options) {
   return compile(csn, options)
 }
 
-module.exports = cds_compile_to_asyncapi
+module.exports = cds_compile_to_asyncapi

package/lib/env/schema.js

@@ -26,6 +26,22 @@ function mergePluginSchema(pluginSchema) {
                     targetSchema._cds_schema_overlays.push('root')
                 }
             }
+
+            if (pluginSchema.export) {
+                const exp = targetSchema.$defs?.cdsRoot?.properties?.export?.properties
+                if (exp) {
+                    Object.assign(exp, pluginSchema.export)
+                    targetSchema._cds_schema_overlays.push('export')
+                }
+            }
+
+            if (pluginSchema.importFrom) {
+                const oneOf = targetSchema.$defs?.importOptions?.from?.oneOf
+                if (oneOf) {
+                    oneOf.push(pluginSchema.importFrom)
+                    targetSchema._cds_schema_overlays.push('importFrom')
+                }
+            }
         }
     }
 }

package/lib/env/schemas/cds-rc.js

@@ -178,79 +178,8 @@ module.exports = {
                     type: "object",
                     description: "Customize cds compile settings",
                     additionalProperties: false,
+                    // export format settings (e.g. `asyncapi`) are contributed by plugins via their package.json `cds.schema.export`
                     properties: {
-                        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 decription 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
-                                }
-                            }
-                        }
                     }
                 },
                 // deploy specific schema
@@ -318,10 +247,6 @@ module.exports = {
         importOptions: {
             from: {
                 oneOf: [
-                    {
-                        const: "asyncapi",
-                        description: "AsyncAPI specification"
-                    },
                     {
                         const: "edmx",
                         description: "OData specification"

package/lib/import/importapi.js

@@ -3,7 +3,6 @@ let { path } = cds.utils;
 let common = require('./common');
 let odata = require('./odata');
 let openapi = require('./openapi');
-let asyncapi = require('./asyncapi');
 let messages = require('./message').getMessages();
 
 module.exports = Object.assign(cds_import, {
@@ -97,15 +96,15 @@ async function cds_import_from_openapi(filepath, options = {}) {
 
 /**
  * This is the import API function to generate CSN from asyncapi files.
+ * cds11: remove once @cap-js/asyncapi is a required project dependency
  * @param {string} filepath
  * - a single valid filepath
  * @returns {object} CSN
  */
 async function cds_import_from_asyncapi(filepath, options = {}) {
-    // validates the input file
     filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
     const src = await common.getContentFromFile(filepath);
-    let csn = asyncapi.asyncapi2csn(src);
+    let csn = require('@cap-js/asyncapi').import.asyncapi2csn(src);
     options.inputFileKind = 'odata';
     return csn;
 }

package/lib/import/message.js

@@ -18,8 +18,6 @@ const messages = {
 	MISSING_ASSOCIATION: 'Association is missing in the input file provided. Please check the edmx file.',
 	COLLECTION_IN_KEY: 'Key Property of an Entity cannot be of the type Collection.',
 	INVALID_OPENAPI_FILE: 'The OpenAPI file is not valid. Specify the correct OpenAPI file.',
-	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: ',
 	NO_RETURN_TYPE: 'No ReturnType found in Function: ',
 	INVALID_ENUM_TYPE: 'The Underlying type provided is not supported for the EnumType: ',

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [25],
-    MAVEN_ARCHETYPE_VERSION: '5.0.0',
+    MAVEN_ARCHETYPE_VERSION: '5.1.1',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',
@@ -29,6 +29,7 @@ module.exports = {
         IAS: 'ias',
         AMS: 'ams',
         HANA: 'hana',
+        HANA_SERVERLESS: 'hana-serverless',
         POSTGRES: 'postgres',
         SQLITE: 'sqlite',
         LIQUIBASE: 'liquibase',

package/lib/init/index.js

@@ -165,7 +165,7 @@ module.exports = class CDSGenerator {
                 const added = cds.cli.command === 'add' && cds.cli.argv[0]?.split(',').includes(plugin) || cds.cli.options.add?.has(plugin)
                 const inProduction = Plugin.hasInProduction(env4('production')) || added
                 DEBUG && console.log(inProduction ? '✅' : '❌', plugin)
-                if (inProduction) await template.combine()
+                if (inProduction) await template.combine(plugin)
             }
         }
 
@@ -237,7 +237,7 @@ module.exports = class CDSGenerator {
                 const creating = ['java', 'nodejs', 'typescript', 'cjs', 'extension']
                 const { command, options, argv } = cds.cli
                 const inOptions = option => command === 'init' && options.add.has(option) ||
-                                            command === 'add'  && argv[0]?.split(',').includes(option)
+                                            command === 'add'  && argv.flatMap(a => a.split(',')).includes(option)
                 if (!exists('pom.xml') && !exists('package.json') && !creating.some(inOptions)) {
                     if (command === 'init') {
                         const project = argv[0] ? argv[0]+' ' : ''