@sap/cds-dk 9.3.2 → 9.4.2

package/CHANGELOG.md

@@ -6,6 +6,64 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## Version 9.4.2 - 2025-10-23
+
+### Changed
+
+- `cds add containerize` does not add app module installations scripts to its `containerize.yaml`. Use `cds up --to k8s` instead.
+- `cds add` is less eager with respect to changing unaffected configuration.
+- `cds add ias` adds less unnecessary configuration in combination with the HTML5 repository.
+- `cds add test` includes the service name in the test suite description.
+
+### Fixed
+
+- `cds add ams` followed by `cds add mta` correctly generates the AMS deployer module.
+- `cds add hana` does not fail if there's no `.cdsrc.json`.
+- `cds up` doesn't try to create a symlink to the monorepo _package-lock.json_ if a submodule-local one already exists.
+- `cds add test` creates correct OData URLs with unqualified entity names in service paths.
+- `cds add http` skips contained composition targets.
+- `cds add sample` no longer comes with an error when creating a Book through Fiori.
+
+## Version 9.4.1 - 2025-10-09
+
+### Added
+
+- `cds add app-frontend` is supported as an alias to `cds add app-front`.
+- `cds add attachments` is supported for Java projects.
+
+### Fixed
+
+- `cds import` adds latest version 4 of `@sap-cloud-sdk` packages.
+- `cds add sample` now uses Integer IDs for Books and Authors again, instead of UUIDs.
+
+## Version 9.4.0 - 2025-10-02
+
+### Added
+
+- `cds add app-front` adds configuration for the new SAP BTP Application Frontend service.
+- `cds add ias` has improved support for XSUAA hybrid projects.
+- `cds add multitenancy` automatically adds upgrade hooks for Node.js projects.
+- `cds deploy` support the generic `--resolve-bindings` option to resolve all bound services. This is helpful for use cases with multiple `hana`-tagged service bindings.
+
+### Changed
+
+- `cds add typescript` and `cds add typer` will now add a `path` entry in the project's _tsconfig.json_ or _jsconfig.json_ respectively, which will mitigate resolution problems with `@cap-js/cds-types`.
+- `cds add multitenancy` adds the `with-mtx` profile to Java apps by default, simplifying local development.
+- `cds import` for EDMX files now maps `Edm.String` types to `cds.String` (before: `cds.LargeString`). Background is that some databases don't support the resulting `NCLOB` type in key fields.
+- `cds build` will now remove dev dependencies starting with `workspace:`, `file:`, as well as the entire `workspace:` block therein, and regenerate the _package-lock.json_ if needed.
+- `cds import` for EDMX correctly imports multiline strings in `DefaultValue`.
+- `cds import` now writes annotations from EDMX files in a flat, i.e. non-structured manner, so that they can be processed by the application runtime.
+- `cds bind` does not fail when setting the profile via `CDS_ENV`.
+- `cds version` is more robust with respect to Java versions.
+
+### Fixed
+
+- `cds add html5-repo` avoids some superfluous configuration combination with `cds add portal`.
+- `cds add handler` ignores external services.
+- `cds add audit-logging` correctly adds the dependency in the _Chart.yaml_ for Helm deployments.
+- `cds deploy --to hana` works with user-provided HANA services.
+- `cds bind` doesn't add the `custom-service:` prefix for Node.js any more.
+
 ## Version 9.3.2 - 2025-09-16
 
 ### Fixed
@@ -27,6 +85,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - `cds add github-actions` correctly generates a release workflow.
 - `cds add github-actions` uses a simplified and more resilient Kyma setup script.
 - `cds import` now correctly imports EDMX files with empty NavigationPropertyPath tags.
+- `cds import` now correctly imports OData v2 EDMX files with `Edm.Time` properties, which have a precision.
 
 ## Version 9.3.0 - 2025-09-01
 

package/bin/bind.js

@@ -94,7 +94,7 @@ async function cds_bind(args, options) {
     }
 
     // Check if command was cds bind. Don't abort for cds deploy.
-    if (process.env.CDS_ENV && process.argv[2] === 'bind') {
+    if (process.argv.includes('--profile') && process.argv[2] === 'bind') {
         throw `Option ${term.bold('--profile')} is no longer supported. Use ${term.bold('--for')} instead to specify the profile to use when storing connection settings.`;
     }
 

package/bin/cds.js

@@ -51,6 +51,9 @@ const cli = {
 
       const task = this.load(cmd, /*else*/(f) => argv.unshift(cmd) && (cmd = 'compile') && _isDefaultCompile(argv, f))
       if (task) {
+
+        if (task._is_new_cmd) return await task.exec (this)
+
         // REVISIT bind: '--' handling for cds bind --exec. Should be moved to cds_cli
         const endOfOptions = argv.indexOf('--')
         let appendArgs = []

package/bin/compile/index.js

@@ -4,13 +4,47 @@ const {colors} = require('../../lib/util/term')
 module.exports = Object.assign ( compile, {
   handleCompletion,
   options: [
-    '--from', '--service', '--lang', '--for', '--to', '--dest', '--log-level', '--flavor', '--dialect', '--sql-dialect', '--openapi:url', '--openapi:servers', '--openapi:config-file', '--odata-version'
+    '--from',
+    '--service',
+    '--lang',
+    '--for',
+    '--to',
+    '--dest',
+    '--log-level',
+    '--flavor',
+    '--dialect',
+    '--sql-dialect',
+    '--openapi:url',
+    '--openapi:servers',
+    '--openapi:config-file',
+    '--odata-version'
   ],
   shortcuts: [
-  undefined, '-s', '-l', '-4', '-2', '-o', undefined, '-f'
+    undefined,
+    '-s',
+    '-l',
+    '-4',
+    '-2',
+    '-o',
+    undefined,
+    '-f'
   ],
   flags: [
-  '--parse', '--plain', '--clean', '--files', '--sources', '--resolved', '--all', '--beta', '--conceptual', '--min', '--docs', '--locations', '--openapi:diagram', '--asyncapi:merged'
+    '--parse',
+    '--plain',
+    '--clean',
+    '--files',
+    '--sources',
+    '--resolved',
+    '--all',
+    '--beta',
+    '--conceptual',
+    '--sort',
+    '--min',
+    '--docs',
+    '--locations',
+    '--openapi:diagram',
+    '--asyncapi:merged'
   ],
   help: `
 # SYNOPSIS
@@ -270,6 +304,9 @@ async function compile (models, options={}) {
     chain = chain.then (next (processor ('for', each)))
   }
 
+  // add processor for sort
+  if (options.sort) chain = chain.then (sort)
+
   // add processors for compiler backends
   if (typeof options.to === 'string')  for (let each of options.to.split(',')) {
     chain = chain.then (next (processor ('to', _suffix=each)))
@@ -382,4 +419,17 @@ function _log (messages, options) {
   cds._log (messages, options)
 }
 
+function sort (o) {
+  const sorted = {}
+  for (let k of Object.keys(o).sort()) {
+    const val = o[k]
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      sorted[k] = sort(val)
+    } else {
+      sorted[k] = val
+    }
+  }
+  return sorted
+}
+
 /* eslint no-console:0 */

package/bin/data-products/get-csn-via-dp-cli.js

@@ -0,0 +1,41 @@
+const child_process = require ('node:child_process')
+const fs = require ('node:fs')
+
+exports.getDataProductCsnViaDpCli = function (ordId) {
+    if (dpCliIsAvailable()) {
+        const [namespace, , name, version] = ordId.split(':')
+        const apiHubName = [namespace, name, version].join('-').replaceAll('.', '-');
+        const dataProductMetadata = getDataProductMetadata(apiHubName);
+        if (dataProductMetadata.OrdId !== ordId) {
+            throw new Error(`Data Product with OrdId ${ordId} not found in API Hub!`)
+        }
+
+        return getDataProductCsn(apiHubName);
+    }
+}
+
+function dpCliIsAvailable() {
+    try {
+        const output = child_process.execSync('which dp-cli').toString();
+        return typeof output === 'string' && output.length > 0;
+    } catch (e) {
+        return false;
+    }
+}
+
+function getDataProductMetadata(apiHubName) {
+    const metadataString = child_process.execSync('dp-cli get -m ' + apiHubName).toString();
+    return JSON.parse(metadataString);
+}
+
+
+function getDataProductCsn(apiHubName) {
+    if (fs.existsSync(apiHubName + '.json')) {
+        throw new Error(`Temporary file ${apiHubName}.json already exists! Please remove it before running this command again - or import directly from the file.`)
+    }
+    // TODO: Do not pipe to file but rather save in memory via custom stream?
+    child_process.execSync('dp-cli get ' + apiHubName, { stdio: ['pipe', fs.openSync(apiHubName + '.json', 'w'), 'pipe'] });
+    const csn = fs.readFileSync(apiHubName + '.json', 'utf-8');
+    fs.unlinkSync(apiHubName + '.json');
+    return JSON.parse(csn);
+}

package/bin/data-products/get-csn.js

@@ -0,0 +1,76 @@
+//
+// get all CSNs related to Data Product from local repo (cloned from https://github.tools.sap/bdc-fos/dp-metadata)
+// and combine them into one CSN file
+//
+// Note: in this repo, ...
+// CSN files              are named like Customer_1.0.0.json -> 3 digit version
+// Data Product ORD files are named like Customer_1.0.0.json -> 3 digit version
+// Data Set files         are named like Customer_1.0.0.json -> 3 digit version
+
+// TODO: sap.capdpprod:dataProduct:CarbonJournalEntries:v1 does not have datasets, only direct data sources?
+
+'use strict'
+
+const fs = require ('node:fs')
+const { mergePartialCsns } = require ('./merge-csns')
+
+/**
+ *
+ * @param ordId
+ * @param kind
+ */
+function ordIdToPath(ordId, kind) {
+  // sap.s4com:dataProduct:Customer:v1
+  const regex = new RegExp('([^:]+):'+ kind + ':([^:]+):v([^:]+)')
+  const match = ordId.match(regex)
+  const namespace = match[1]  // "sap.s4com"
+  const name      = match[2]  // "Customer"
+  const version   = match[3]  // "1"
+  return `${namespace.replace('.','/')}/${name}_${version}.json`  // TODO version handling!
+}
+
+/**
+ *
+ * @param pathToRepo
+ * @param region
+ * @param landscape
+ * @param dataProduct_ordId
+ */
+exports.getDataProductCsnFromLocalRepo = function (pathToRepo, region, landscape, dataProduct_ordId) {
+  const dataProduct_ordId_long_version = dataProduct_ordId + '.0.0'
+  const path_prefix = pathToRepo + `/environments/${region}/${landscape}/defaults`
+
+
+  const dataSource_ordIds = getDataSources()
+
+  let partialCsns = []
+  for (let dataSource_ordId of dataSource_ordIds) {
+    // read csn file
+    const csn_path = `${path_prefix}/csn_documents/`+ ordIdToPath(dataSource_ordId, 'dataSource')
+    // environments/eu10/stage-canary/defaults/csn_documents/sap/s4com/Customer_1.0.0.json
+    const csn = JSON.parse(fs.readFileSync(csn_path, { encoding: 'utf-8' }))
+    partialCsns.push(csn)
+  }
+
+  const mergedCsn = mergePartialCsns(partialCsns)
+  return mergedCsn
+
+  /**
+   *
+   */
+  function getDataSources() {
+    const dpDefinitionFile = JSON.parse(fs.readFileSync(`${path_prefix}/dataproducts/` + ordIdToPath(dataProduct_ordId_long_version, 'dataProduct'), { encoding: 'utf-8' }))
+
+    const dpdV2 = dpDefinitionFile?.dpdVersion === 'v2'
+
+    if(dpdV2) {
+      return dpDefinitionFile.dependsOn.filter(dep => dep.includes(':dataSource:'))
+    } else {
+      // read dataset file
+      const dataset_path = `${path_prefix}/datasets/` + ordIdToPath(dataProduct_ordId_long_version, 'dataProduct')
+      // environments/eu10/stage-canary/defaults/datasets/sap/s4com/Customer_1.0.0.json
+      const dataset = JSON.parse(fs.readFileSync(dataset_path, { encoding: 'utf-8' }))
+      return dataset.dataSources
+    }
+  }
+}

package/bin/data-products/import.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+const cds = require ('../../lib/cds.js')
+const { write, path } = cds.utils
+const { Export } = require ('../export.js')
+
+
+class Import extends Export {
+
+  options = Import.options // for IntelliSense
+  static options = { ...super.options,
+    to: './apis/imported/*',
+    'data-product': false,
+  }
+  static filename = __filename;
+
+  usage() {
+    const md = path.join(__dirname, '../help/import.md')
+    return super.usage = cds.utils.fs.readFileSync (md,'utf8')
+  }
+
+  async load (sources, o = this.options) {
+    if (!o['data-product']) return super.load (sources)
+    if (!sources || sources[0] === '*') return this.help()
+    const { load_data_product } = require ('./index.js')
+    return load_data_product (sources,o)
+  }
+
+  export_to (o = this.options) {
+    if (!o.apiResourceOrdId) return super.export_to (o)
+    this.package_name = o.apiResourceOrdId.replace(':apiResource:','-').replaceAll(':','-').replaceAll('.','-').toLowerCase()
+    return this.options.to.slice(0,-1) + this.package_name
+  }
+
+  *export_texts() {
+    const bundles = this.csn.i18n; if (!bundles) return
+    const serialize = texts => Object.entries(texts).map(([k,v]) => k +'='+ v.replace(/'/g, "''")).join('\n')
+    const write = texts => ({ to: file => this.write(serialize(texts)).to(file) })
+    for (let [locale,texts] of Object.entries(bundles))
+      yield write(texts) .to (`_i18n/i18n_${locale}.properties`)
+  }
+
+  *export_models (model, o = this.options) {
+
+    // If no data product ID is specified, fall back to the default export behavior
+    if (!o.apiResourceOrdId) return yield* super.export_models(model, o);
+
+    const normalizeEOL = process.platform === 'win32' ? (str) => str.replace(/\r?\n/g, EOL) : str => str;
+    const {EOL} = require ('node:os')
+
+    const { definitions, extensions } = model;
+    yield this.write (
+      `// This file acts as a central facade to exported service definitions.`+ EOL +
+      `// You can modify it to tweak things, without your changes being overridden.`+ EOL +
+      `using from './services';`+
+      (extensions ? EOL + `using from './annotations';` : '')
+    ) .to ('index.cds')
+
+    const definitionsCdl = cds.compile.to.cdl ({definitions}, {renderCdlCommonNamespace:false})
+    yield this.write (normalizeEOL(definitionsCdl)) .to ('services.cds')
+
+    if (extensions) {
+      // shorten names in the "annotate" to match the local name defined in "using"
+      const services = Object.keys(definitions).filter (k => definitions[k].kind === 'service')
+      if (services.length === 1 && services[0].includes('.')) {
+        let prefix = services[0].substring(0, services[0].lastIndexOf('.'))  + '.'
+        extensions.forEach(o => {o.annotate = o.annotate.replace(prefix, '') })
+      }
+
+      let annotationsCdl = cds.compile.to.cdl ({extensions: extensions});
+
+      if (services.length === 1)
+        annotationsCdl = `using { ${services[0]} } from './services';` + EOL + EOL + annotationsCdl
+
+      yield this.write (normalizeEOL(annotationsCdl)) .to ('annotations.cds')
+    }
+    // TODO: What does this do? Do we need it or also remove it?
+    o.data = false;
+  }
+
+  async export_package_json (o = this.options) {
+
+    // If no data product ID is specified, fall back to the default export behavior
+    if (!o.apiResourceOrdId) return super.export_package_json(o)
+
+    const [,major,minor=0,patch=0] = o.apiResourceOrdId.match(/v(\d+)(?:\.(\d+)(?:\.(\d+))?)?/)
+    const srv = o.apiResourceOrdId.replace(':apiResource:','.').replaceAll(':','.')
+
+    await super.export_package_json ({
+      name: this.package_name,
+      version: major + '.' + minor + '.' + patch,
+      cds: {
+        requires: {
+          [srv]: {
+            kind: 'data.product',
+            model: this.package_name,
+            ordId: o.apiResourceOrdId
+          }
+        }
+      }
+    })
+
+    return this.update_package_json();
+  }
+
+  async update_package_json(){
+    const rootPackageJsonPath = path.join(cds.root + '/package.json');
+    const rootPackageJson = require(rootPackageJsonPath);
+    rootPackageJson.dependencies = rootPackageJson.dependencies || {};
+    rootPackageJson.dependencies[this.package_name] = `file:${this.options.to}`;
+    await write(rootPackageJson).to(rootPackageJsonPath);
+  }
+}
+
+module.exports = Object.assign (Import._for_cds_dk(), { Import })

package/bin/data-products/index.js

@@ -0,0 +1,30 @@
+const { getDataProductCsnFromLocalRepo } = require ('./get-csn.js')
+const { getDataProductCsnViaDpCli } = require ('./get-csn-via-dp-cli.js')
+const { prepareCsn } = require ('./prepare-csn.js')
+const fs = require ('node:fs/promises')
+const path = require ('node:path')
+
+exports.load_data_product  = async function (sources, o) {
+  let service = /\/([^/]+)\//.exec(o.services)?.[1].replaceAll('\\.','.')
+  if (!service.includes(':apiResource:')) {
+    const [,namespace,name,version] = /^(.+)-([^-]+)-(v[0-9]+)\.json$/ .exec (path.basename(String(sources)))
+    service = namespace.replace(/-/g,'.') + ':apiResource:' + name + ':' + version
+  }
+
+  const ordId = o.apiResourceOrdId = service
+  delete o.services // otherwise we minify by ordID, which results in empty csn.definitions
+  const from = String (sources)
+
+  const csn = await getCsn(from, ordId);
+  const [,namespace, name, version] = /^([^:]+):apiResource:([^:]+):(v[0-9]+)/.exec(ordId)
+  return prepareCsn (csn, namespace + '.' + name + '.' + version, ordId)
+}
+
+async function getCsn(from, ordId) {
+  if (/dp-metadata$/.test(from))
+    return getDataProductCsnFromLocalRepo (from, 'eu10', 'stage-canary', ordId)
+  else if(from === 'dp-cli')
+    return getDataProductCsnViaDpCli(ordId)
+  else
+    return JSON.parse(await fs.readFile(from, { encoding: 'utf-8' }))
+}

package/bin/data-products/merge-csns.js

@@ -0,0 +1,46 @@
+'use strict'
+
+/**
+ * Merges multiple partial CSNs (Core Schema Notations) into a single CSN.
+ * @param {Array<object>} partialCsns - An array of partial CSN objects to be merged.
+ * @returns {object} - The merged CSN object.
+ * @throws Will throw an error if there are conflicting definitions or translations.
+ */
+exports.mergePartialCsns = function (partialCsns) {
+  const parentCsn = { definitions: Object.create(null), i18n: Object.create(null) }
+
+  for (const partialCsn of partialCsns) {
+    for (const definitionName in partialCsn.definitions) {
+      const definition = partialCsn.definitions[definitionName]
+      if (parentCsn.definitions[definitionName]) {
+        const existing = JSON.stringify(parentCsn.definitions[definitionName])
+        const current = JSON.stringify(definition)
+        if (existing !== current) {
+          throw new Error('Error for definition ' + definitionName + ' - it already exists!')
+        }
+      } else {
+        parentCsn.definitions[definitionName] = definition
+      }
+    }
+
+    for (const i18nLanguageCode in partialCsn.i18n) {
+      const i18n = partialCsn.i18n[i18nLanguageCode]
+      if (!parentCsn.i18n[i18nLanguageCode]) {
+        parentCsn.i18n[i18nLanguageCode] = Object.create(null)
+      }
+
+      for (const translationCode in i18n) {
+        if (parentCsn.i18n[i18nLanguageCode][translationCode]) {
+          const existing = parentCsn.i18n[i18nLanguageCode][translationCode]
+          const current = i18n[translationCode]
+          if (existing !== current) {
+            throw new Error('Error for i18n:' + i18nLanguageCode + ' with translation ' + translationCode + ' - it already exists!')
+          }
+        }
+        parentCsn.i18n[i18nLanguageCode][translationCode] = i18n[translationCode]
+      }
+    }
+  }
+
+  return parentCsn
+}